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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Grouping Anagrams by Sorted Key

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

DSA Go

package main

import (
	"fmt"
	"sort"
	"strings"
)

func groupAnagrams(strs []string) [][]string {
	m := make(map[string][]string)
	for _, s := range strs {
		chars := strings.Split(s, "")
		sort.Strings(chars)
		sorted := strings.Join(chars, "")
		m[sorted] = append(m[sorted], s)
	}
	result := [][]string{}
	for _, group := range m {
		result = append(result, group)
	}
	return result
}

func main() {
	input := []string{"eat", "tea", "tan", "ate", "nat", "bat"}
	groups := groupAnagrams(input)
	fmt.Println(groups)
}

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

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

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

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

💡 Hint

Think about how the map stores groups by sorted keys and how iteration order over maps in Go is random.

The code groups strings by their sorted character sequence as keys in a map. Since Go maps iterate in random order, the groups can appear in any order. Option D shows a valid grouping with all anagrams together, matching the map's grouping but in a different order than option D. Options B and C have incorrect groupings.

🧠 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 are unique identifiers for anagram groups, so all anagrams share the same key.

B Because sorting strings makes the algorithm faster by avoiding comparisons.

C Because sorted strings reduce memory usage by compressing the keys.

D Because sorted strings help to remove duplicate characters from the strings.

💡 Hint

Think about what makes anagrams similar and how keys in a map work.

Anagrams have the same characters in different orders. Sorting the characters of each string creates a unique key that is the same for all anagrams, allowing them to be grouped together in the map.

🔧 Debug

advanced

Identify the Error in Group Anagrams Code

What error will this Go code produce when trying to group anagrams using a hash map?

DSA Go

package main

import (
	"fmt"
	"sort"
	"strings"
)

func groupAnagrams(strs []string) [][]string {
	m := make(map[string][]string)
	for _, s := range strs {
		chars := strings.Split(s, "")
		sort.Strings(chars)
		m[chars] = append(m[chars], s)
	}
	result := [][]string{}
	for _, group := range m {
		result = append(result, group)
	}
	return result
}

func main() {
	input := []string{"eat", "tea", "tan"}
	fmt.Println(groupAnagrams(input))
}

A Output: [["eat", "tea"], ["tan"]]

B Runtime panic: index out of range

C Syntax error: cannot use []string as map key type

D No error, outputs grouped anagrams correctly

💡 Hint

Check the type used as the map key and what Go allows as map keys.

In Go, map keys must be comparable types. Slices (like []string) are not comparable and cannot be used as map keys. Using chars (a []string) as a key causes a compile-time error.

🚀 Application

advanced

Count Unique Anagram Groups

Given the list of strings ["listen", "silent", "enlist", "google", "gogole", "abc"], how many unique anagram groups will the grouping function create?

A 4

B 3

C 2

D 5

💡 Hint

Group strings by their sorted characters and count distinct groups.

The groups are: ["listen", "silent", "enlist"] (all anagrams), ["google", "gogole"] (anagrams), and ["abc"] alone. So total 3 groups.

❓ Predict Output

expert

Output of Group Anagrams with Unicode Characters

What is the output of this Go code that groups anagrams including Unicode characters?

DSA Go

package main

import (
	"fmt"
	"sort"
	"strings"
)

func groupAnagrams(strs []string) [][]string {
	m := make(map[string][]string)
	for _, s := range strs {
		chars := strings.Split(s, "")
		sort.Slice(chars, func(i, j int) bool {
			return chars[i] < chars[j]
		})
		sorted := strings.Join(chars, "")
		m[sorted] = append(m[sorted], s)
	}
	result := [][]string{}
	for _, group := range m {
		result = append(result, group)
	}
	return result
}

func main() {
	input := []string{"résumé", "sérumé", "ésumér", "hello", "olleh"}
	groups := groupAnagrams(input)
	fmt.Println(groups)
}

A [["résumé", "sérumé", "ésumér"], ["hello", "olleh"]]

B [["hello", "olleh"], ["résumé", "sérumé", "ésumér"]]

C [["résumé"], ["sérumé"], ["ésumér"], ["hello", "olleh"]]

D [["résumé", "sérumé"], ["ésumér"], ["hello", "olleh"]]

💡 Hint

Unicode characters are sorted lexicographically; anagrams share the same sorted sequence.

The three accented words are anagrams sharing the same sorted characters, grouped together. 'hello' and 'olleh' form another group. Map iteration order is random but both A and B show correct groups; however, only A matches the actual output order from running the code.

Practice

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

easy

A. Use the last letter of each word as the key

B. Use the length of words as keys to group anagrams

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

D. Use the first letter of each word as the key

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 C

4. Quick Check:

   Sorted string key = group anagrams [OK]

Hint: Sort letters to find anagram groups quickly [OK]

Common Mistakes:

• Using word length as key misses different anagrams
• Using first or last letter groups unrelated words
• Not sorting letters before using as key

2. Which Go code snippet correctly initializes a hash map to group anagrams?

easy

A. groups := make(map[string][]string)

B. groups := map[string]string{}

C. groups := make([]string, 0)

D. groups := map[int][]string{}

Solution

1. Step 1: Identify map key and value types

   Key should be string (sorted word), value should be slice of strings (anagrams).

2. Step 2: Check Go map initialization syntax

   make(map[string][]string) creates a map with string keys and string slice values.

3. Final Answer:

   groups := make(map[string][]string) -> Option A

4. Quick Check:

   Correct map type and initialization [OK]

Hint: Use map[string][]string for grouping anagrams [OK]

Common Mistakes:

• Using map[string]string instead of map[string][]string
• Using slice instead of map
• Using wrong key or value types

3. What is the output of the following Go code?

package main
import (
  "fmt"
  "sort"
  "strings"
)
func groupAnagrams(strs []string) map[string][]string {
  groups := make(map[string][]string)
  for _, word := range strs {
    letters := strings.Split(word, "")
    sort.Strings(letters)
    key := strings.Join(letters, "")
    groups[key] = append(groups[key], word)
  }
  return groups
}
func main() {
  input := []string{"bat", "tab", "eat", "tea"}
  result := groupAnagrams(input)
  fmt.Println(result)
}

medium

A. map[bat:[bat] tab:[tab] eat:[eat] tea:[tea]]

B. map[abt:[bat] tab:[tab] aet:[eat] tea:[tea]]

C. map[bat:[bat tab] eat:[eat tea]]

D. map[abt:[bat tab] aet:[eat tea]]

Solution

1. Step 1: Sort letters of each word

   "bat" and "tab" sorted to "abt"; "eat" and "tea" sorted to "aet".

2. Step 2: Group words by sorted key

   Words with key "abt" grouped as ["bat", "tab"], with key "aet" grouped as ["eat", "tea"].

3. Final Answer:

   map[abt:[bat tab] aet:[eat tea]] -> Option D

4. Quick Check:

   Sorted keys group anagrams correctly [OK]

Hint: Sorted keys map to anagram groups [OK]

Common Mistakes:

• Not sorting letters before grouping
• Using original words as keys
• Incorrect map output format

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

func groupAnagrams(strs []string) map[string][]string {
  groups := make(map[string][]string)
  for _, word := range strs {
    letters := strings.Split(word, "")
    sort.Strings(letters)
    key := letters[0]
    groups[key] = append(groups[key], word)
  }
  return groups
}

medium

A. Appending word to wrong map key

B. Using letters[0] as key instead of full sorted string

C. Not initializing the map before use

D. Missing import for strings package

Solution

1. Step 1: Check key creation logic

   Key is set as letters[0], only first letter of sorted word, not full sorted string.

2. Step 2: Understand impact on grouping

   Using only first letter groups unrelated words, failing to group anagrams correctly.

3. Final Answer:

   Using letters[0] as key instead of full sorted string -> Option B

4. Quick Check:

   Full sorted string needed as key [OK]

Hint: Use full sorted string as key, not just first letter [OK]

Common Mistakes:

• Using partial key instead of full sorted string
• Forgetting to join letters into string key
• Not sorting letters before key creation

5. Given the input list ["listen", "silent", "enlist", "google", "gogole", "abc"], which Go code snippet correctly returns the grouped anagrams as a slice of slices of strings (ignoring order)?

hard

A. func groupAnagrams(strs []string) [][]string {
groups := make(map[string][]string)
for _, word := range strs {
letters := strings.Split(word, "")
sort.Strings(letters)
key := strings.Join(letters, "")
groups[key] = append(groups[key], word)
}
result := [][]string{}
for _, group := range groups {
result = append(result, group)
}
return result
}

B. func groupAnagrams(strs []string) [][]string {
groups := make(map[int][]string)
for _, word := range strs {
key := len(word)
groups[key] = append(groups[key], word)
}
result := [][]string{}
for _, group := range groups {
result = append(result, group)
}
return result
}

C. func groupAnagrams(strs []string) [][]string {
groups := make(map[string]string)
for _, word := range strs {
letters := strings.Split(word, "")
sort.Strings(letters)
key := strings.Join(letters, "")
groups[key] = word
}
result := [][]string{}
for _, group := range groups {
result = append(result, []string{group})
}
return result
}

D. func groupAnagrams(strs []string) [][]string {
groups := make(map[string][]string)
for _, word := range strs {
key := word
groups[key] = append(groups[key], word)
}
result := [][]string{}
for _, group := range groups {
result = append(result, group)
}
return result
}

Solution

1. Step 1: Use sorted string as key and map to slice of strings

   func groupAnagrams(strs []string) [][]string { groups := make(map[string][]string) for _, word := range strs { letters := strings.Split(word, "") sort.Strings(letters) key := strings.Join(letters, "") groups[key] = append(groups[key], word) } result := [][]string{} for _, group := range groups { result = append(result, group) } return result } correctly sorts letters, joins them as key, and appends words to groups[key].

2. Step 2: Convert map values to slice of slices

   func groupAnagrams(strs []string) [][]string { groups := make(map[string][]string) for _, word := range strs { letters := strings.Split(word, "") sort.Strings(letters) key := strings.Join(letters, "") groups[key] = append(groups[key], word) } result := [][]string{} for _, group := range groups { result = append(result, group) } return result } collects all groups into a slice of slices and returns it.

3. Final Answer:

   Option A code correctly groups anagrams and returns slice of slices -> Option A

4. Quick Check:

   Sorted key + map to slices + collect groups = correct [OK]

Hint: Sort letters, map to slices, then collect groups [OK]

Common Mistakes:

• Using word length as key groups wrong words
• Using map[string]string loses multiple anagrams per key
• Using original word as key misses grouping