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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Grouping Anagrams by Sorted Key

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

DSA Javascript

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

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

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

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

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

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

💡 Hint

Think about how sorting each string groups anagrams together as the same key.

The code sorts each string to create a key. Anagrams have the same sorted key, so they are grouped together in the map. The final output is an array of these grouped 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 convert all letters to uppercase for uniformity.

B Because sorted strings are unique identifiers for anagram groups, making it easy to group them.

C Because sorting strings makes the code run faster for all inputs.

D Because sorted strings remove duplicate characters from the original strings.

💡 Hint

Think about what anagrams share in common after sorting.

Anagrams have the same letters in different orders. Sorting puts letters in order, so all anagrams become the same sorted string. This makes it a perfect key to group them.

🔧 Debug

advanced

Identify the Error in Grouping Anagrams Code

What error does the following code produce when grouping anagrams using a hash map? function groupAnagrams(strs) { const map = {}; for (const str of strs) { const sorted = str.split('').sort().join(''); if (!map[sorted]) { map[sorted] = str; } else { map[sorted].push(str); } } return Object.values(map); } const input = ["bat", "tab"]; console.log(groupAnagrams(input));

A Output: [["bat", "tab"]]

B SyntaxError: Unexpected token '.'

C Output: [["bat"], ["tab"]]

D TypeError: map[sorted].push is not a function

💡 Hint

Check what type map[sorted] is initialized as before push is called.

map[sorted] is initialized as a string (str), not an array. Calling push on a string causes a TypeError.

❓ Predict Output

advanced

Output of Group Anagrams Using Character Count as Key

What is the output of this JavaScript code that groups anagrams using character count as the key in a hash map?

DSA Javascript

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

const input = ["abc", "bca", "cab", "xyz", "zyx", "zxy"];
console.log(groupAnagrams(input));

A [["abc", "bca", "cab"], ["xyz", "zyx", "zxy"]]

B [["abc"], ["bca"], ["cab"], ["xyz"], ["zyx"], ["zxy"]]

C [["abc", "xyz"], ["bca", "zyx"], ["cab", "zxy"]]

D [["xyz", "zyx", "zxy"], ["abc", "bca", "cab"]]

💡 Hint

Character count arrays uniquely identify anagram groups.

The code counts characters for each string and uses the counts as keys. Anagrams have identical counts, so they group together. The output groups the three "abc" anagrams and the three "xyz" anagrams.

🧠 Conceptual

expert

Why Use Character Count Instead of Sorting for Grouping Anagrams?

What is the main advantage of using character count arrays as keys instead of sorting strings when grouping anagrams?

A Character count keys allow grouping in linear time per string, improving performance for long strings.

B Character count keys use less memory than sorted strings for all inputs.

C Sorting strings is not reliable for grouping anagrams because it changes the original strings.

D Character count keys automatically handle uppercase and lowercase letters without extra code.

💡 Hint

Consider the time complexity of sorting vs counting characters.

Sorting each string takes O(k log k) time (k = string length). Counting characters takes O(k) time. For very long strings, counting is faster and more efficient.

Practice

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

easy

A. Group words by their length using a hash map

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

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

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

Solution

1. Step 1: Understand anagrams

   Anagrams are words with the same letters in different orders, so sorting letters gives a unique key.

2. Step 2: Use sorted string as hash map key

   By sorting each word and using it as a key, all anagrams map to the same key and can be grouped.

3. Final Answer:

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

4. Quick Check:

   Sorted word keys group anagrams = C [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 of the following JavaScript code snippets correctly initializes an empty hash map to group anagrams?

easy

A. const map = {};

B. const map = Map();

C. const map = [];

D. const map = new Set();

Solution

1. Step 1: Identify hash map initialization in JavaScript

   JavaScript objects ({}) are commonly used as hash maps for key-value pairs.

2. Step 2: Analyze the options

   {} creates a simple hash map using bracket notation like map[key]. Map() without new throws TypeError. [] creates an array unsuitable for key-value pairs. new Set() stores unique values, not mappings.

3. Final Answer:

   const map = {}; -> Option A

4. Quick Check:

   Object literal {} is simplest hash map = A [OK]

Hint: Use {} to create a simple hash map in JavaScript [OK]

Common Mistakes:

• Using array [] instead of object
• Using Set which doesn't store key-value pairs
• Confusing Map and object initialization

3. What is the output of the following code?

function groupAnagrams(words) {
  const map = {};
  for (const word of words) {
    const sorted = word.split('').sort().join('');
    if (!map[sorted]) map[sorted] = [];
    map[sorted].push(word);
  }
  return Object.values(map);
}

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

medium

A. SyntaxError

B. [['bat'], ['tab'], ['eat'], ['tea'], ['ate']]

C. [['bat', 'tab'], ['eat', 'tea', 'ate']]

D. [['bat', 'tab', 'eat', 'tea', 'ate']]

Solution

1. Step 1: Sort each word and group in map

   Words 'bat' and 'tab' both sort to 'abt', so grouped together. 'eat', 'tea', 'ate' all sort to 'aet', grouped together.

2. Step 2: Return grouped anagrams as array of arrays

   Object.values(map) returns arrays of grouped words: [['bat', 'tab'], ['eat', 'tea', 'ate']].

3. Final Answer:

   [['bat', 'tab'], ['eat', 'tea', 'ate']] -> Option C

4. Quick Check:

   Sorted keys group words = [['bat','tab'],['eat','tea','ate']] [OK]

Hint: Sort words, group by sorted key, return grouped arrays [OK]

Common Mistakes:

• Returning flat list instead of grouped arrays
• Not sorting words before grouping
• Syntax errors from missing brackets

4. Find the error in this code snippet for grouping anagrams:

function groupAnagrams(words) {
  const map = {};
  for (const word of words) {
    const sorted = word.sort().join('');
    if (!map[sorted]) map[sorted] = [];
    map[sorted].push(word);
  }
  return Object.values(map);
}

medium

A. map should be initialized as a Map object

B. word.sort() is invalid because word is a string, not an array

C. Missing return statement

D. Using Object.values on map is incorrect

Solution

1. Step 1: Identify the error in sorting

   word is a string, and strings do not have a sort() method. It must be split into an array first.

2. Step 2: Correct approach to sort letters

   Use word.split('').sort().join('') to sort letters of the string correctly.

3. Final Answer:

   word.sort() is invalid because word is a string, not an array -> Option B

4. Quick Check:

   Strings need split() before sort() = B [OK]

Hint: Split string to array before sorting letters [OK]

Common Mistakes:

• Calling sort() directly on string
• Not splitting string before sorting
• Confusing Map object with plain object

5. Given the input array ['listen', 'silent', 'enlist', 'google', 'gogole', 'abc', 'cab'], which of the following is the correct grouped anagrams output using a hash map approach?

hard

A. [['listen', 'silent', 'enlist'], ['google', 'gogole'], ['abc', 'cab']]

B. [['listen', 'silent'], ['enlist', 'google'], ['gogole', 'abc', 'cab']]

C. [['listen'], ['silent'], ['enlist'], ['google'], ['gogole'], ['abc'], ['cab']]

D. [['listen', 'silent', 'enlist', 'google', 'gogole', 'abc', 'cab']]

Solution

1. Step 1: Sort each word to find keys

   'listen', 'silent', 'enlist' all sort to 'eilnst'; 'google', 'gogole' sort to 'eggloo'; 'abc', 'cab' sort to 'abc'.

2. Step 2: Group words by sorted keys

   Group words with same sorted key together: [['listen', 'silent', 'enlist'], ['google', 'gogole'], ['abc', 'cab']].

3. Final Answer:

   [['listen', 'silent', 'enlist'], ['google', 'gogole'], ['abc', 'cab']] -> Option A

4. Quick Check:

   Sorted keys group anagrams correctly = A [OK]

Hint: Sort letters, group by key, collect arrays [OK]

Common Mistakes:

• Mixing groups with different sorted keys
• Grouping by word length instead of letters
• Returning flat list instead of grouped arrays