How do I get the length of a list?

I need to write a function that is passed in a list of strings, and returns a new list with all the strings of the original list that had a length of two. So the list: list = ['oh','hello','there','!!'] Will return: ['oh','!!'] I've absolutely hit a brick wall here. I'm positive I need to use the len() function, but no matter how I try to implement it, I keep getting how many elements are in the list. Please help if y'can!

def sift_two(theOtherList):
    for element in theOtherList:
       if element == len(2):
            return element

TL/DR: Are linked lists the best solution for an Entity list in C or is there a better solution?

I'm currently in the process of refactoring a small tutorial roguelike I made in C in order to make the code conform to best practices. In my game I have a list of Items and a list of Monsters which I can iterate through in order to make monsters take turns or see if the player is able to pick up an Item. Until recently, I had these lists implemented simply as arrays of pointers with a respective int counter to keep count of how many Items or Monsters there were at any given time:

Item* items[15] = { NULL };
int n_items = 0;

The arrays were bounded with a hard-coded limit (15 in this example). This limit could easily be observed when creating a new level and keep the number of items below the max, but once the player was given the option to 'drop' items, this limit became a problem, as any item carried over from other levels and dropped in a newly created dungeon level would now be added back into the item array and could easily overflow it.

In order to solve this issue I've implemented a singly linked list struct as:

typedef struct List 
{
    union {
        Actor* actor;
        Item* item;
    };
    struct List* next;
} List;

This List struct uses the following function to add new Items to the list:

void appendItem(List* head, Item* item)
{
    List* temp = head;
    
    while (temp->next)
    {
        temp = temp->next;
    }
    temp->next = malloc(sizeof(List));
    temp = temp->next;
    temp->item = item;
    temp->next = NULL;
}

The list can now be initiated as:

List* items = malloc(sizeof(List));
items->item = NULL;
items->next = NULL;

And I can iterate through the list with:

List* temp = items;
while (temp = temp->next)
{
    checkSomething(temp->item);
}

This setup now allows me to forget about a limit on items or actors and just add them as needed. However, before I continue with this structure and refactor all other arrays to use this, I wanted to ask if anyone knows whether this would be the best solution for the problem of the item and monster lists in a C roguelike. I've delved into the original Rogue source code and saw that the THING union has a prev and next pointers so I believe that it uses a similar setup, but I don't know if that is a good modern C solution. If any C developers would share any best-practices that they know of regarding this issue, it would be much appreciated. Thanks for taking the time to read through this and for any reply!

TL/DR: Are linked lists the best solution for an Entity list in C or is there a better solution?