Write a method that returns the top K most frequent strings from a sequence.

• Null input returns an empty list.
• k <= 0 returns an empty list.
• Ignore null, empty, or whitespace values.
• Use case-insensitive counting but return normalized lower-case values.

I would count normalized values in a dictionary and then sort the unique values by count descending and value ascending. For normal interview sizes this is clear and reliable. If the interviewer pushes on very large input, I would discuss a heap to avoid sorting every unique value, but I would start with the simpler correct solution.

public static IReadOnlyList<string> TopKFrequent(IEnumerable<string?>? values, int k)
{
    if (values is null || k <= 0)
    {
        return Array.Empty<string>();
    }

    var counts = new Dictionary<string, int>(StringComparer.Ordinal);
    foreach (var value in values)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            continue;
        }

        var normalized = value.Trim().ToLowerInvariant();
        counts[normalized] = counts.TryGetValue(normalized, out var count) ? count + 1 : 1;
    }

    return counts
        .OrderByDescending(pair => pair.Value)
        .ThenBy(pair => pair.Key, StringComparer.Ordinal)
        .Take(k)
        .Select(pair => pair.Key)
        .ToList();
}

Counting is O(n). Sorting unique values is O(m log m), where m is the number of unique normalized values. Space is O(m). A heap can reduce selection cost when m is huge and k is small.

• k is zero or negative.
• k is larger than the number of unique values.
• Values with different casing and spaces.
• Frequency ties.
• All inputs are blank.

• Use ties to verify alphabetical secondary ordering.
• Use API, api, and api to verify normalization.
• Use k larger than unique count to verify no padding.

• Returning values in dictionary order.
• Forgetting to handle k <= 0.
• Counting blank strings as real values.
• Overengineering with a heap before getting the simple version correct.