Valid Anagram: Python and TypeScript Solutions, Explained

The Valid Anagram Problem

You are given two strings, s and t. Return true if t is an anagram of s: it uses every character of s exactly as often, just rearranged. Otherwise return false.

Example 1

Input: s = "listen", t = "silent"
Output: true
Why: both strings contain one each of e, i, l, n, s and t.

Example 2

Input: s = "aab", t = "abb"
Output: false
Why: the same set of letters appears in both, but the counts differ: two a's against one. Checking only which letters appear is a common wrong answer.

Assumptions to confirm

• Is the input lowercase English letters only, or any Unicode text? (It changes whether a fixed array of 26 counts is enough.)
• Do spaces and capital letters count? ("Dormitory" and "dirty room" are anagrams only if you ignore both.)
• Are two empty strings anagrams? (Usually yes.)

Start With the Simple Answer: Sort Both Strings

The quickest correct answer sorts both strings and compares them. If the sorted versions are equal, the strings are anagrams. It takes O(n log n) time and, in most languages, O(n) extra space for the sorted copies.

Say this first. It is short, obviously correct and a fine fallback. Then point out what it does that you do not need: it puts every character in order, when the question only cares how many times each one appears. Counting is cheaper than ordering, which leads to the linear solution.

The Optimal Approach: Count the Letters

Valid Anagram Solution in Python and TypeScript

Both versions follow the steps above. The length check is what lets them skip a final pass to confirm every count is zero.

Python

from collections import Counter


def is_anagram(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False
    counts = Counter(s)
    for ch in t:
        counts[ch] -= 1
        if counts[ch] < 0:
            return False
    return True

TypeScript

function isAnagram(s: string, t: string): boolean {
  if (s.length !== t.length) return false;
  const counts = new Map<string, number>();
  for (const ch of s) counts.set(ch, (counts.get(ch) ?? 0) + 1);
  for (const ch of t) {
    const left = (counts.get(ch) ?? 0) - 1;
    if (left < 0) return false;
    counts.set(ch, left);
  }
  return true;
}

In Python, Counter(s) == Counter(t) is a valid one-line answer and worth mentioning, but write the explicit loop if the interviewer asks how it works. Many interviewers do.

Time and Space Complexity

How to Talk Through Valid Anagram in an Interview

A strong spoken answer follows the same five beats every time:

1. Clarify: "Is it lowercase letters only, or any characters? Do spaces and case matter?"
2. Brute force: "I could sort both strings and compare them, which is O(n log n)."
3. Optimise: "I only need counts, not order, so I can count the first string in a map and subtract the second. That is one pass over each string, so O(n)."
4. Code: say why the length check comes first and why a negative count means you can stop early.
5. Test: run "listen" and "silent", then "aab" and "abb", then two empty strings. State O(n) time and O(k) space.

On an easy problem like this, the difference between a pass and a strong pass is usually the clarifying questions and the edge cases, not the code.

Edge Cases and Common Follow-Ups

Practise Valid Anagram in a Mock Coding Round

Valid Anagram is often used as a warm-up in a screening round, so the interviewer is listening for how clearly you clarify and test, not just whether the code works. Rehearsing it out loud, under time pressure, is the quickest way to make that habit automatic.

MockIF runs mock coding interviews with a voice AI interviewer in a real in-browser editor, in Python and TypeScript. It runs your code against tests, asks you to explain your approach, adds follow-up questions the way a real interviewer would, and then scores your answer and gives specific feedback. Each session costs 2 credits. It is free to start with 5 credits, then monthly or 3-monthly plans, or one-off credit packs (see pricing).

Frequently Asked Questions