Group Anagrams Using Hash Map in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Grouping Anagrams by Sorted Key

What is the output of the following TypeScript code that groups anagrams using a hash map with sorted strings as keys?

DSA Typescript

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map<string, string[]>();
  for (const s of strs) {
    const key = s.split('').sort().join('');
    if (!map.has(key)) {
      map.set(key, []);
    }
    map.get(key)!.push(s);
  }
  return Array.from(map.values());
}

const input = ["eat", "tea", "tan", "ate", "nat", "bat"];
console.log(groupAnagrams(input));

A [["eat", "ate"], ["tea", "tan"], ["nat", "bat"]]

B [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]

C [["bat"], ["tan", "nat"], ["eat", "tea", "ate"]]

D [["eat"], ["tea"], ["tan"], ["ate"], ["nat"], ["bat"]]

💡 Hint

Think about how sorting each string helps group anagrams together as keys in the map.

The code sorts each string to create a key. Anagrams have the same sorted key, so they are grouped together in the map. The output is an array of arrays where each inner array contains anagrams.

🧠 Conceptual

intermediate

Why Use Sorted Strings as Keys in Grouping Anagrams?

Why do we use the sorted version of each string as the key in the hash map when grouping anagrams?

A Because sorted strings allow us to avoid using a hash map altogether.

B Because sorting strings makes the algorithm run faster than using the original strings.

C Because sorted strings are unique identifiers for all anagrams of that string.

D Because sorted strings reduce the memory usage of the hash map.

💡 Hint

Think about what property all anagrams share when their letters are sorted.

All anagrams have the same letters in different orders. Sorting the letters makes all anagrams identical strings, which can be used as unique keys to group them.

🔧 Debug

advanced

Identify the Error in Grouping Anagrams Code

What error will this TypeScript code produce when grouping anagrams?

DSA Typescript

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map<string, string[]>();
  for (const s of strs) {
    const key = s.split('').sort();
    if (!map.has(key)) {
      map.set(key, []);
    }
    map.get(key)!.push(s);
  }
  return Array.from(map.values());
}

const input = ["eat", "tea", "tan"];
console.log(groupAnagrams(input));

A RuntimeError: Cannot use array as Map key

B No error, outputs grouped anagrams correctly

C TypeError: map.get(...) is undefined

D SyntaxError: missing join() after sort()

💡 Hint

Consider what type is used as the key in the Map and if it is valid.

The code uses an array (result of split and sort) as a key in the Map. JavaScript Maps use object identity for keys, so different arrays with same contents are different keys, causing incorrect grouping.

❓ Predict Output

advanced

Output of Group Anagrams Using Character Count as Key

What is the output of this TypeScript code that groups anagrams using character count as the key?

DSA Typescript

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map<string, string[]>();
  for (const s of strs) {
    const count = new Array(26).fill(0);
    for (const char of s) {
      count[char.charCodeAt(0) - 97]++;
    }
    const key = count.join('#');
    if (!map.has(key)) {
      map.set(key, []);
    }
    map.get(key)!.push(s);
  }
  return Array.from(map.values());
}

const input = ["abc", "bca", "cab", "bac", "acb", "cba"];
console.log(groupAnagrams(input));

A [["abc", "cab", "acb"], ["bca", "bac", "cba"]]

B [["abc"], ["bca"], ["cab"], ["bac"], ["acb"], ["cba"]]

C [["abc", "bca"], ["cab", "bac"], ["acb", "cba"]]

D [["abc", "bca", "cab", "bac", "acb", "cba"]]

💡 Hint

All input strings are anagrams of each other, so they should be grouped together.

The character count array creates a unique key for all anagrams. Since all input strings have the same characters, they all map to the same key and are grouped together.

🧠 Conceptual

expert

Why is Character Count Key More Efficient than Sorting for Grouping Anagrams?

Why might using a character count array as a key be more efficient than sorting each string when grouping anagrams?

A Because counting characters is O(n) per string, while sorting is O(n log n), making counting faster for long strings.

B Because sorting changes the original strings, which is not allowed.

C Because character count keys use less memory than sorted strings.

D Because sorting cannot be used as a key in a hash map.

💡 Hint

Think about the time complexity of sorting vs counting characters.

Sorting each string takes O(n log n) time, while counting characters takes O(n). For long strings, counting characters is faster and produces a fixed-size key.

Practice

1. What is the main idea behind grouping anagrams using a hash map?

easy

A. Count the number of vowels in each word and group by count

B. Use sorted strings as keys to group words with the same letters

C. Group words by their length using a hash map

D. Use the first letter of each word as the key in the hash map

Solution

1. Step 1: Understand anagrams

   Anagrams are words with the same letters in different orders.

2. Step 2: Use sorted string as key

   Sorting letters of each word gives a unique key for all its anagrams.

3. Final Answer:

   Use sorted strings as keys to group words with the same letters -> Option B

4. Quick Check:

   Sorted word key groups anagrams = A [OK]

Hint: Sort each word to find its anagram group key [OK]

Common Mistakes:

• Grouping by word length only
• Using first letter as key
• Counting vowels instead of letters

2. Which TypeScript syntax correctly initializes a hash map to group anagrams?

easy

A. const map = new Map();

B. const map = new Map();

C. const map = new Map();

D. const map = new Map();

Solution

1. Step 1: Identify key and value types

   Keys are sorted strings, values are arrays of strings (anagrams).

2. Step 2: Match types in Map initialization

   Map matches key as string and value as string array.

3. Final Answer:

   const map = new Map(); -> Option A

4. Quick Check:

   Map key=string, value=string array = D [OK]

Hint: Map keys are strings; values are arrays of strings [OK]

Common Mistakes:

• Using number as key instead of string
• Using number array as value
• Confusing value type with number

3. What is the output of this TypeScript code?

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map();
  for (const str of strs) {
    const key = str.split('').sort().join('');
    if (!map.has(key)) map.set(key, []);
    map.get(key)!.push(str);
  }
  return Array.from(map.values());
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat']));

medium

A. [["eat", "tan", "bat"], ["tea", "nat", "ate"]]

B. [["eat"], ["tea"], ["tan"], ["ate"], ["nat"], ["bat"]]

C. [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]

D. [["bat", "nat", "tan"], ["ate", "tea", "eat"]]

Solution

1. Step 1: Sort each word to create keys

   "eat", "tea", "ate" all sort to "aet"; "tan", "nat" to "ant"; "bat" to "abt".

2. Step 2: Group words by keys in map

   Map groups: "aet" -> ["eat", "tea", "ate"], "ant" -> ["tan", "nat"], "abt" -> ["bat"].

3. Final Answer:

   [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]] -> Option C

4. Quick Check:

   Sorted keys group anagrams = B [OK]

Hint: Sort letters to find groups, then collect values [OK]

Common Mistakes:

• Mixing groups by length or first letter
• Returning individual words instead of groups
• Incorrect grouping order

4. Identify the bug in this TypeScript code for grouping anagrams:

function groupAnagrams(strs: string[]): string[][] {
  const map = new Map();
  for (const str of strs) {
    const key = str.split('').sort();
    if (!map.has(key)) map.set(key, []);
    map.get(key)!.push(str);
  }
  return Array.from(map.values());
}

medium

A. The key is an array, should be a string after join()

B. map.get(key) returns undefined, should check with has() first

C. Using Map instead of plain object causes error

D. Missing return type annotation on function

Solution

1. Step 1: Check key creation

   str.split('').sort() returns an array, not a string key.

2. Step 2: Fix key by joining sorted array

   Use str.split('').sort().join('') to create string key for map.

3. Final Answer:

   The key is an array, should be a string after join() -> Option A

4. Quick Check:

   Key must be string, not array = A [OK]

Hint: Join sorted array to form string key [OK]

Common Mistakes:

• Using array as map key without joining
• Ignoring map.has() check
• Confusing Map with plain object

5. Given the input array ['abc', 'bca', 'cab', 'xyz', 'zyx', 'zxy', 'aabb', 'baba'], which code snippet correctly groups anagrams using a hash map and filters out groups with less than 3 words?

hard

A. const map = new Map();
for (const str of strs) {
const key = str[0];
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(str);
}
return Array.from(map.values()).filter(group => group.length >= 3);

B. const map = new Map();
for (const str of strs) {
const key = str.length.toString();
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(str);
}
return Array.from(map.values()).filter(group => group.length >= 3);

C. const map = new Map();
for (const str of strs) {
const key = str.split('').reverse().join('');
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(str);
}
return Array.from(map.values()).filter(group => group.length >= 3);

D. const map = new Map();
for (const str of strs) {
const key = str.split('').sort().join('');
if (!map.has(key)) map.set(key, []);
map.get(key)!.push(str);
}
return Array.from(map.values()).filter(group => group.length >= 3);

Solution

1. Step 1: Create keys by sorting letters

   Sorting letters groups anagrams correctly, e.g., "abc", "bca", "cab" all become "abc".

2. Step 2: Filter groups with 3 or more words

   Use filter to keep only groups where length >= 3.

3. Final Answer:

   Code snippet using sorted keys and filtering groups by length >= 3 -> Option D

4. Quick Check:

   Sort keys + filter groups >= 3 = C [OK]

Hint: Sort letters for keys, then filter groups by size [OK]

Common Mistakes:

• Using word length or first letter as key
• Reversing letters instead of sorting
• Not filtering groups by size