Valid Anagram

Valid Anagram - Problem

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

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.

Input & Output

Example 1 — Basic Anagram

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

› Output: true

💡 Note: Both strings contain exactly the same characters with the same frequencies: a(3), g(1), m(1), n(1), r(1). The letters are just rearranged.

Example 2 — Not an Anagram

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

› Output: false

💡 Note: The strings have different characters: 'rat' has 't' but 'car' has 'c'. They cannot be anagrams of each other.

Example 3 — Different Lengths

$ Input: s = "listen", t = "silent"

› Output: true

💡 Note: Both strings have the same length and characters: e(1), i(1), l(1), n(1), s(1), t(1). They are perfect anagrams.

Constraints

1 ≤ s.length, t.length ≤ 5 × 10⁴
s and t consist of lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 45 f Facebook 38 B Bloomberg 32 M Microsoft 28

The key insight is that anagrams have identical character frequency distributions. The optimal approach uses a single counter array to track character differences in O(n) time and O(1) space by incrementing for characters in s and decrementing for characters in t.

Common Approaches

✓ Brute Force - Sort Both Strings

⏱️ Time: O(n log n) Space: O(n)

Convert both strings to character arrays, sort them alphabetically, and check if the sorted strings are identical. If they match, the original strings are anagrams.

Frequency Count with Hash Map

⏱️ Time: O(n) Space: O(1)

Use a hash map to count the frequency of each character in both strings. Two strings are anagrams if they have identical character frequency distributions.

Single Pass Counter Array

⏱️ Time: O(n) Space: O(1)

Use one pass through both strings simultaneously with a single frequency array. Increment for characters in s, decrement for characters in t. If all counts are zero at the end, the strings are anagrams.

Brute Force - Sort Both Strings — Algorithm Steps

Convert both strings to character arrays
Sort both arrays alphabetically
Compare sorted arrays element by element

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Strings

Input strings s and t in original order

Sort Characters

Sort both strings alphabetically

Compare

Check if sorted strings match exactly

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

int solution(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    if (sLen != tLen) {
        return 0;
    }
    
    char* sCopy = malloc((sLen + 1) * sizeof(char));
    char* tCopy = malloc((tLen + 1) * sizeof(char));
    strcpy(sCopy, s);
    strcpy(tCopy, t);
    
    qsort(sCopy, sLen, sizeof(char), compare);
    qsort(tCopy, tLen, sizeof(char), compare);
    
    int result = strcmp(sCopy, tCopy) == 0;
    
    free(sCopy);
    free(tCopy);
    
    return result;
}

int main() {
    char s[10001], t[10001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    int result = solution(s, t);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting both strings takes O(n log n) time where n is the length of the strings

✓ Linear Growth

Space Complexity

O(n)

Creating character arrays for sorting requires O(n) extra space

✓ Linear Space

321.3K Views

High Frequency

~15 min Avg. Time

8.5K 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

Brute Force - Sort Both Strings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler