Valid Anagram - Practice Coding Problems

Valid Anagram - Problem

An anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once. For example, "listen" and "silent" are anagrams of each other.

Given two strings s and t, determine if t is an anagram of s. Return true if they are anagrams, false otherwise.

Note: You may assume the strings contain only lowercase English letters.

Input & Output

example_1.py — Basic Anagram

$ Input: s = "anagram", t = "nagaram"

› Output: true

💡 Note: Both strings contain exactly the same characters with the same frequencies: a(3), n(1), g(1), r(1), m(1). Rearranging 'anagram' gives 'nagaram'.

example_2.py — Not Anagram

$ Input: s = "rat", t = "car"

› Output: false

💡 Note: The strings have different characters. 'rat' contains 'r', 'a', 't' while 'car' contains 'c', 'a', 'r'. They don't have the same character frequencies.

example_3.py — Different Lengths

$ Input: s = "a", t = "ab"

› Output: false

💡 Note: Strings of different lengths cannot be anagrams since they don't contain the same number of characters.

Constraints

1 ≤ s.length, t.length ≤ 5 × 10⁴
s and t consist of lowercase English letters only
Follow-up: What if the inputs contain Unicode characters?

Visualization

Tap to expand

Understanding the Visualization

Initialize Balance

Start with empty hash table (balanced scale)

Process Characters

For each position i: add s[i] weight (+1), remove t[i] weight (-1)

Check Final Balance

If all character counts are zero, the strings are anagrams

Key Takeaway

🎯 Key Insight: Two strings are anagrams if and only if they have identical character frequency distributions. The one-pass hash table approach elegantly solves this by maintaining a running balance of character counts.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a single-pass hash table approach with O(n) time complexity. For each position, we increment the count for characters in string s and decrement for characters in string t. If the strings are anagrams, all counts will be zero at the end. This approach is more efficient than sorting O(n log n) and more elegant than the two-pass hash table method.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Strings)	O(n log n)	O(n)	Sort both strings and compare character by character with two pointers
Brute Force (Character Matching)	O(n²)	O(n)	For each character in s, find and remove matching character in t
One-Pass Hash Table (Optimal)	O(n)	O(k)	Increment counts for s and decrement for t simultaneously in single pass
Two-Pass Hash Table	O(n)	O(k)	Count characters in first string, then verify counts with second string

Two Pointers (Sorted Strings) — Algorithm Steps

Check if strings have equal length (early exit if not)
Convert both strings to character arrays
Sort both character arrays
Use two pointers to compare sorted arrays element by element
If any characters don't match, return false
If all characters match, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Both Strings

Transform 'listen' → 'eilnst', 'silent' → 'eilnst'

Two Pointer Comparison

Compare sorted strings character by character

Perfect Match

All characters match - strings are anagrams

Code -

solution.c — C

int compare(const void *a, const void *b) {
    return (*(char*)a - *(char*)b);
}

bool isAnagram(char* s, char* t) {
    int lenS = strlen(s);
    int lenT = strlen(t);
    
    if (lenS != lenT) {
        return false;
    }
    
    // Create copies and sort
    char* sCopy = malloc((lenS + 1) * sizeof(char));
    char* tCopy = malloc((lenT + 1) * sizeof(char));
    strcpy(sCopy, s);
    strcpy(tCopy, t);
    
    qsort(sCopy, lenS, sizeof(char), compare);
    qsort(tCopy, lenT, sizeof(char), compare);
    
    // Compare using two pointers
    int left = 0;
    int right = 0;
    
    while (left < lenS && right < lenT) {
        if (sCopy[left] != tCopy[right]) {
            free(sCopy);
            free(tCopy);
            return false;
        }
        left++;
        right++;
    }
    
    free(sCopy);
    free(tCopy);
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting both strings, comparison is O(n)

⚡ Linearithmic

Space Complexity

O(n)

Creating character arrays for sorting

⚡ Linearithmic Space

125.6K Views

Very High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Sorted Strings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler