How Do You Check Anagrams?

Two strings are anagrams when they contain exactly the same characters with exactly the same counts. The direct check is to build a frequency table for the first string and then walk the second string, decrementing the counts. If any count would go negative, the strings differ; if every character is consumed without a shortfall, they match.

def is_anagram(a, b):
    if len(a) != len(b):
        return False
    counts = {}
    for char in a:
        counts[char] = counts.get(char, 0) + 1
    for char in b:
        if char not in counts:
            return False
        counts[char] -= 1
        if counts[char] < 0:
            return False
    return True

print(is_anagram("listen", "silent"))
print(is_anagram("listen", "silentx"))

The outputs are True and False. The second call fails on the length check before the loop even starts, which is the cheapest way to reject a mismatch.

The mechanism is that the frequency table turns the question of whether the two multisets are equal into a question you can answer one character at a time. It is a single pass over each string, so the time is O of n where n is the length, and the space is O of k where k is the number of distinct characters, which is bounded by the alphabet size for typical text.

The trade-off to name is the space. The count table uses memory proportional to the alphabet, while the sorted-signature approach also needs memory because sorting produces a new list. If you need to run this check over millions of pairs, the practical cost is dominated by the allocation, and a single reusable counter or a bytes comparison after sorting may be faster in practice. The count approach is also the one to reach for when you only want to compare a handful of strings, since it is the clearest to read.

Sorting both strings and comparing the results is correct for the same reason as counting: if two strings contain the same characters with the same multiplicities, then sorting them puts the characters in the same order. The sorted list becomes a canonical signature for the multiset of characters.

a = "listen"
b = "silent"
print(sorted(a) == sorted(b))
print(sorted("hello"), sorted("world"))

The first line prints True, and the second prints the two sorted lists, which have nothing in common. The signature for both words is the list e, i, l, n, s, t.

The cost is the sort. Sorting is O of n log n compared with the linear cost of counting, and it allocates a list of n characters rather than a table of a handful of distinct ones. So the sorted trick is asymptotically worse, and in practice it is usually slower too, because the sort dominates the comparison.

The reason to use it anyway is clarity and reusability. One line expresses the whole idea, which matters in a whiteboard interview or in a quick script. The better reason is the grouping problem, where you need to bucket many words by anagram class: computing a sorted signature gives you a hashable key directly, so the words can be placed in a dictionary in a single pass, and that grouping pattern is where the sorted signature earns its keep even though the count table could do the same job.