Write a C# method that counts words in a text after normalizing case and ignoring punctuation.

Implement CountWords(string text) returning a list of (word, count) pairs. Words are case-insensitive, punctuation is ignored, and results are ordered by count descending, then word ascending. Treat letters and digits as word characters.

Input: "API, api! SQL api?" Output: [ ("api", 3), ("sql", 1) ]

• Null or whitespace input returns an empty list.
• Words are compared case-insensitively by lower-case normalized value.
• Punctuation separates words and is not part of a word.
• Output order is deterministic: higher count first, then alphabetical.

I would scan the string once and build the current word with a StringBuilder. When I hit a non-letter-or-digit character, I flush the current word into a dictionary. At the end I flush once more for a trailing word. Then I order by count descending and word ascending. I would say this out loud because the important parts are normalization, delimiter handling, and deterministic output.

public static IReadOnlyList<(string Word, int Count)> CountWords(string? text)
{
    if (string.IsNullOrWhiteSpace(text))
    {
        return Array.Empty<(string Word, int Count)>();
    }

    var counts = new Dictionary<string, int>(StringComparer.Ordinal);
    var current = new StringBuilder();

    void Flush()
    {
        if (current.Length == 0)
        {
            return;
        }

        var word = current.ToString().ToLowerInvariant();
        counts[word] = counts.TryGetValue(word, out var count) ? count + 1 : 1;
        current.Clear();
    }

    foreach (var ch in text)
    {
        if (char.IsLetterOrDigit(ch))
        {
            current.Append(ch);
        }
        else
        {
            Flush();
        }
    }

    Flush();

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

The scan is O(n), where n is the text length. Sorting unique words costs O(k log k), where k is the number of unique words. Space is O(k) for the dictionary plus the current word buffer.

• Empty string, whitespace, or null.
• Repeated punctuation such as api---sql.
• Mixed case such as API api Api.
• Digits inside words such as http2.
• Ties that require alphabetical ordering.

• Use inputs with no punctuation and with only punctuation.
• Use words at the very end of the string to catch missing final flush.
• Use ties to catch non-deterministic dictionary ordering.
• Use mixed case to confirm normalization happens before counting.

• Forgetting to flush the final word.
• Counting punctuation as part of the word.
• Returning dictionary iteration order.
• Using culture-sensitive casing when invariant casing is enough.