Valid Anagram

Problem

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

An anagram uses exactly the same characters with exactly the same frequencies.

Intuition

Order is irrelevant. Counts are everything.

Two strings are anagrams if and only if every character appears the same number of times in both strings. That turns the problem from "compare permutations" into "compare frequency tables."

Because LeetCode constrains the input to lowercase English letters, we do not even need a HashMap. A fixed array of length 26 is enough.

Approach

impl Solution {
    pub fn is_anagram(s: String, t: String) -> bool {
        if s.len() != t.len() {
            return false;
        }

        let mut freq = [0i32; 26];
        for &b in s.as_bytes() {
            freq[(b - b'a') as usize] += 1;
        }
        for &b in t.as_bytes() {
            freq[(b - b'a') as usize] -= 1;
        }

        freq.into_iter().all(|x| x == 0)
    }
}

function isAnagram(s: string, t: string): boolean {
  if (s.length !== t.length) return false;

  const freq = new Array<number>(26).fill(0);
  for (let i = 0; i < s.length; i++) {
    freq[s.charCodeAt(i) - 97]++;
    freq[t.charCodeAt(i) - 97]--;
  }

  return freq.every((x)=> x= 0);
}

Edge cases

• Different lengths — impossible to be anagrams.
• Repeated letters — the whole point of the frequency table is to preserve multiplicity.
• Unicode variant — if the alphabet were arbitrary Unicode, switch to HashMap<char, i32> / Map<string, number>.

Takeaway

When order does not matter but multiplicity does, count.

That idea scales from anagram checks to bucketed counting, histogram comparisons, and signature-building for grouping problems like #49 Group Anagrams.