Group Anagrams

Problem

Given an array of strings strs, group the anagrams together. You may return the answer in any order.

Intuition

The grouping key cannot be the raw string, because "eat" and "tea" should land in the same bucket.

What is identical for all anagrams? Their character counts.

So the problem becomes: build a canonical signature for each string, then hash by that signature. Sorting each string works, but because the alphabet is lowercase English letters, a 26-count signature is cheaper and more direct.

Approach

use std::collections::HashMap;

impl Solution {
    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
        let mut groups: HashMap<[u8; 26], Vec<String>> = HashMap::new();

        for s in strs {
            let mut key = [0u8; 26];
            for &b in s.as_bytes() {
                key[(b - b'a') as usize] += 1;
            }
            groups.entry(key).or_default().push(s);
        }

        groups.into_values().collect()
    }
}

function groupAnagrams(strs: string[]): string[][] {
  const groups = new Map<string, string[]>();

  for (const s of strs) {
    const count = new Array<number>(26).fill(0);
    for (let i = 0; i < s.length; i++) {
      count[s.charCodeAt(i) - 97]++;
    }
    const key= count.join("#");
    if (!groups.has(key)) groups.set(key, []);
    groups.get(key)!.push(s);
  }

  return Array.from(groups.values());
}

Edge cases

• Single string — it forms a one-element group.
• Empty string — its signature is 26 zeros; all empty strings belong together.
• Different group order — the problem allows any ordering of groups and words within groups.

Takeaway

A good hash key is often the whole problem.

For #49, the hard part is not the map itself. It is inventing a key that captures "anagram equivalence" exactly. That is a recurring design move in hash-based problems.