Group Anagrams Using Hash Map in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the hash map for grouping anagrams.

DSA Typescript

const map = new Map<string, string[]>();

for (const word of words) {
  const sorted = word.split('').sort().join('');
  if (!map.has([1])) {
    map.set(sorted, []);
  }
}

Drag options to blanks, or click blank then click option'

Aword

Bmap

Csorted

Dwords

Attempts:

3 left

💡 Hint

Common Mistakes

Using the original word as the key instead of the sorted word.

Using the map object itself as the key.

We use the sorted version of the word as the key in the map to group anagrams together.

2fill in blank

medium

Complete the code to add the current word to the correct group in the map.

DSA Typescript

map.get(sorted)!.[1](word);

Drag options to blanks, or click blank then click option'

Apush

Bpop

Cshift

Dunshift

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop or shift which remove elements instead of adding.

Using unshift which adds to the start, but push is more common here.

We use push to add the current word to the array of anagrams for the sorted key.

3fill in blank

hard

Fix the error in the code to return the grouped anagrams as an array of arrays.

DSA Typescript

return Array.from(map.[1]());

Drag options to blanks, or click blank then click option'

Akeys

Bvalues

Centries

DforEach

Attempts:

3 left

💡 Hint

Common Mistakes

Using keys() which returns the sorted strings.

Using entries() which returns key-value pairs.

We want the values of the map, which are arrays of anagrams, so we use values().

4fill in blank

hard

Fill both blanks to complete the function that groups anagrams.

DSA Typescript

function groupAnagrams(words: string[]): string[][] {
  const map = new Map<string, string[]>();
  for (const word of words) {
    const sorted = word.split('').[1]().join('');
    if (!map.has(sorted)) {
      map.set(sorted, []);
    }
    map.get(sorted)!.[2](word);
  }
  return Array.from(map.values());
}

Drag options to blanks, or click blank then click option'

Asort

Breverse

Cpush

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using reverse instead of sort.

Using pop instead of push.

We sort the characters to get the key and push the word into the array for that key.

5fill in blank

hard

Fill all three blanks to create a concise one-liner that groups anagrams.

DSA Typescript

const groupAnagrams = (words: string[]): string[][] => {
  const map = new Map<string, string[]>();
  for (const word of words) {
    const key = word.split('').[1]().join('');
    map.set(key, (map.get(key) || []).[2](word) && map.get(key) || [word]);
  }
  return Array.from(map.[3]());
};

Drag options to blanks, or click blank then click option'

Asort

Bpush

Cvalues

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push.

Using keys instead of values for the final return.

Sort characters for key, push word into array, and return map values as grouped anagrams.

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