Loading…

easyBasicsSometimes asked

Valid Anagram

Basics · 6 min

Given two strings s and t of lowercase letters, return whether t is an anagram of s (same letters, same counts).

In plain English

Two strings are anagrams iff they have identical character counts. A 26-slot count array compares them.

Examples

Example 1

Input: s = "listen", t = "silent"
Output: true
Note: Same letters.

Example 2

Input: s = "rat", t = "car"
Output: false
Note: Different letters.

Example 3

Input: s = "a", t = "ab"
Output: false
Note: Different lengths.

Constraints

0 ≤ s.length, t.length ≤ 10^4
Lowercase letters

Clarifying questions2First question: Lowercase letters only?Explore questions

Q1.Lowercase letters only?
Yes — that justifies the 26-int array; Unicode needs a map.
Q2.Is case/space significant?
Assumed letters only; I'd normalise if needed.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

If lengths differ, return false. Otherwise count each letter of s (++) and each of t (−−) in a 26-int array; they're anagrams iff every count ends at 0. O(n).

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you compare frequencies in O(n) rather than sorting.

Where candidates slip

No length guard, or defaulting to an O(n log n) sort.

How to stand out

Note the array works for a–z; for Unicode switch to a hash map.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Frequency count (26 array)

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What must be true of the two strings' letter counts?

2Hint 2Explore hint

Length check first, then a 26-int frequency array.

3Hint 3Explore hint

++ for s, −− for t; all zero at the end means anagram.

A · Core idea

Two strings are anagrams iff they contain the same letters with the same counts. A 26-slot count array compares frequencies in O(n): increment for each letter of s, decrement for each of t; they match iff every count ends at 0.

Why the length check first. Different lengths can't be anagrams, and the check lets you walk both strings together with one index. It also short-circuits the obvious negatives instantly.

Why ++ for s and −− for t in one array. Using a single array, s adds and t subtracts; equal frequencies cancel to all-zeros. This is neater (and one array) versus building two maps and comparing them.

Why O(1) space. The count array is fixed at 26 regardless of input size (for lowercase a–z). For full Unicode you'd use a hash map instead. Sorting both strings also works but is O(n log n) — the count array is the O(n) answer.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "ab", t = "ba"

i=0

+a, −b

Statea:1, b:-1

Final resulttrue

C · Code with teaching comments

solution.javaJava

Frequency count (26 array) — optimal

2 teaching notes

1
public boolean isAnagram(String s, String t) {
2
    if (s.length() != t.length()) return false;
3
    int[] count = new int[26];
4
    for (int i = 0; i < s.length(); i++) {
5
        // Tally s's letters.
6
        count[s.charAt(i) - 'a']++;
7
        // Untally t's letters; all-zero at the end means a match.
8
        count[t.charAt(i) - 'a']--;
9
    }
10
    for (int c : count) if (c != 0) return false;
11
    return true;
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Sorting both strings (O(n log n)) also works, but the count array is the O(n) answer.

ComplexityO(n) time, O(1) space — one pass over both strings (O(n)) with a fixed 26-int array (O(1) space).

E · Edge cases and pitfalls5s = "rat", t = "car" — Counts don't cancel → false.Explore edge cases

Edge cases handled

s = "rat", t = "car"Counts don't cancel → false.
s = "a", t = "ab"Length differs → false.
s = "", t = ""Both empty → true.

Pitfalls

Skipping the length check and mishandling unequal lengths.
Sorting when an O(n) count is expected.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic boolean isAnagram(String s, String t) { if (s.length() != t.length()) return false; int[] count = new int[26]; for (int i = 0; i < s.length(); i++) { count[s.charAt(i) - 'a']++;Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

No length check

Without it, 'abc' vs 'ab' may pass a partial comparison; differing lengths can never be anagrams.

Explore the code comparison

Don't write this

// straight to counting, no guard
int[] c = new int[26]; ...

Write this instead

if (s.length() != t.length()) return false;
int[] c = new int[26]; ...

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Letter-frequency compare

Code pattern to memorize

len equal? count[s]++ count[t]--; all zero?

Rules to remember

1Length must match.
2++ for s, −− for t.
3All zero ⟹ anagram.

Use this pattern when

Permutation/anagram checks
Comparing multisets of characters

Interview takeaway

Anagram = equal letter frequencies; a 26-array compares them in O(n).

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Letter-frequency compare. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Group Anagrams
Coming soon
Key each word by its sorted form or count signature.
Character Frequency
The frequency map this compares.

easyBasicsSometimes asked

Valid Anagram

Basics · 6 min

Given two strings s and t of lowercase letters, return whether t is an anagram of s (same letters, same counts).

In plain English

Two strings are anagrams iff they have identical character counts. A 26-slot count array compares them.

Examples

Example 1

Input: s = "listen", t = "silent"
Output: true
Note: Same letters.

Example 2

Input: s = "rat", t = "car"
Output: false
Note: Different letters.

Example 3

Input: s = "a", t = "ab"
Output: false
Note: Different lengths.

Constraints

0 ≤ s.length, t.length ≤ 10^4
Lowercase letters

Clarifying questions2First question: Lowercase letters only?Explore questions

Q1.Lowercase letters only?
Yes — that justifies the 26-int array; Unicode needs a map.
Q2.Is case/space significant?
Assumed letters only; I'd normalise if needed.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

If lengths differ, return false. Otherwise count each letter of s (++) and each of t (−−) in a 26-int array; they're anagrams iff every count ends at 0. O(n).

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you compare frequencies in O(n) rather than sorting.

Where candidates slip

No length guard, or defaulting to an O(n log n) sort.

How to stand out

Note the array works for a–z; for Unicode switch to a hash map.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Frequency count (26 array)

TimeO(n)SpaceO(1)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What must be true of the two strings' letter counts?

2Hint 2Explore hint

Length check first, then a 26-int frequency array.

3Hint 3Explore hint

++ for s, −− for t; all zero at the end means anagram.

A · Core idea

Why the length check first. Different lengths can't be anagrams, and the check lets you walk both strings together with one index. It also short-circuits the obvious negatives instantly.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "ab", t = "ba"

i=0

+a, −b

Statea:1, b:-1

Final resulttrue

C · Code with teaching comments

solution.javaJava

Frequency count (26 array) — optimal

2 teaching notes

1
public boolean isAnagram(String s, String t) {
2
    if (s.length() != t.length()) return false;
3
    int[] count = new int[26];
4
    for (int i = 0; i < s.length(); i++) {
5
        // Tally s's letters.
6
        count[s.charAt(i) - 'a']++;
7
        // Untally t's letters; all-zero at the end means a match.
8
        count[t.charAt(i) - 'a']--;
9
    }
10
    for (int c : count) if (c != 0) return false;
11
    return true;
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Sorting both strings (O(n log n)) also works, but the count array is the O(n) answer.

ComplexityO(n) time, O(1) space — one pass over both strings (O(n)) with a fixed 26-int array (O(1) space).

E · Edge cases and pitfalls5s = "rat", t = "car" — Counts don't cancel → false.Explore edge cases

Edge cases handled

s = "rat", t = "car"Counts don't cancel → false.
s = "a", t = "ab"Length differs → false.
s = "", t = ""Both empty → true.

Pitfalls

Skipping the length check and mishandling unequal lengths.
Sorting when an O(n) count is expected.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

No length check

Without it, 'abc' vs 'ab' may pass a partial comparison; differing lengths can never be anagrams.

Explore the code comparison

Don't write this

// straight to counting, no guard
int[] c = new int[26]; ...

Write this instead

if (s.length() != t.length()) return false;
int[] c = new int[26]; ...

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Letter-frequency compare

Code pattern to memorize

len equal? count[s]++ count[t]--; all zero?

Rules to remember

1Length must match.
2++ for s, −− for t.
3All zero ⟹ anagram.

Use this pattern when

Permutation/anagram checks
Comparing multisets of characters

Interview takeaway

Anagram = equal letter frequencies; a 26-array compares them in O(n).

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Letter-frequency compare. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Group Anagrams
Coming soon
Key each word by its sorted form or count signature.
Character Frequency
The frequency map this compares.