Group Anagrams Using Hash Map in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new list for each group of anagrams.

DSA Java

if (!map.containsKey(key)) {
    map.put(key, new [1]<>());
}

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

AArrayList

BHashMap

CLinkedList

DHashSet

Attempts:

3 left

💡 Hint

Common Mistakes

Using HashMap instead of a list for values.

Using HashSet which does not preserve order.

We use ArrayList to store the list of anagrams for each key in the map.

2fill in blank

medium

Complete the code to add the current word to the list of anagrams.

DSA Java

map.get(key).[1](word);

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

Aadd

Bput

Cinsert

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using put() which is for maps, not lists.

Using append() which is not a Java List method.

The add() method adds an element to the ArrayList.

3fill in blank

hard

Fix the error in sorting the characters of the word to create the key.

DSA Java

char[] chars = word.toCharArray();
Arrays.[1](chars);

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

Aorder

Bsorted

Csort

Darrange

Attempts:

3 left

💡 Hint

Common Mistakes

Using Arrays.sorted() which does not exist.

Using order() or arrange() which are not Java methods.

Arrays.sort() sorts the array of characters in place.

4fill in blank

hard

Fill both blanks to convert the sorted char array back to a string key.

DSA Java

String key = new String([1]);
map.putIfAbsent(key, new [2]<>());

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

Achars

Bword

CArrayList

DHashMap

Attempts:

3 left

💡 Hint

Common Mistakes

Using word instead of chars to create the key.

Using HashMap instead of ArrayList for the map value.

We create a string from the sorted chars and initialize a new ArrayList for the map value.

5fill in blank

hard

Fill all three blanks to return the grouped anagrams as a list of lists.

DSA Java

return new ArrayList<>([1].[2]());

// where [3] is the map variable

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

Amap

Bvalues

CentrySet

DkeySet

Attempts:

3 left

💡 Hint

Common Mistakes

Using keySet() or entrySet() instead of values().

Using a different variable name than the map.

We get the collection of values from the map and convert it to a list to return grouped anagrams.

Practice

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

easy

A. Count the length of each word and group by length

B. Group words by their first letter only

C. Use sorted strings as keys to group words that are anagrams

D. Use the original word as the key in the hash map

Solution

1. Step 1: Understand anagram grouping

   Anagrams are words with the same letters in different orders. Sorting letters gives a unique key for each group.

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 together.

3. Final Answer:

   Use sorted strings as keys to group words that are anagrams -> Option C

4. Quick Check:

   Sorted string key = group anagrams [OK]

Hint: Sort each word and use as key to group anagrams [OK]

Common Mistakes:

• Grouping by word length only
• Using original word as key without sorting
• Grouping by first letter only

2. Which of the following Java code snippets correctly initializes a hash map to group anagrams?

easy

A. HashMap map = new HashMap<>();

B. HashMap map = new HashMap<>();

C. Map map = new HashMap<>();

D. Map map = new HashMap<>();

Solution

1. Step 1: Identify correct map types for grouping

   We need keys as strings (sorted words) and values as lists of strings (grouped anagrams).

2. Step 2: Check each option's type correctness

   Map map = new HashMap<>(); uses Map, which is correct. Others have wrong key or value types.

3. Final Answer:

   Map map = new HashMap<>(); -> Option D

4. Quick Check:

   Key=String, Value=List<String> for grouping [OK]

Hint: Use Map for grouping anagrams [OK]

Common Mistakes:

• Using int as key type
• Using String as value instead of List<String>
• Using List<String> as key type

3. What is the output of the following Java code snippet?

String[] words = {"eat", "tea", "tan", "ate", "nat", "bat"};
Map map = new HashMap<>();
for (String word : words) {
  char[] chars = word.toCharArray();
  Arrays.sort(chars);
  String key = new String(chars);
  map.computeIfAbsent(key, k -> new ArrayList<>()).add(word);
}
System.out.println(map.values());

medium

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

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

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

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

Solution

1. Step 1: Sort each word to get keys

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

2. Step 2: Group words by sorted keys

   Words with key "aet" grouped: [eat, tea, ate]; key "ant": [tan, nat]; key "abt": [bat].

3. Final Answer:

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

4. Quick Check:

   Sorted keys group anagrams correctly [OK]

Hint: Sort words, group by sorted key, print grouped lists [OK]

Common Mistakes:

• Not sorting words before grouping
• Adding words to wrong groups
• Printing keys instead of grouped values

4. Identify the error in this Java code for grouping anagrams:

String[] words = {"bat", "tab", "eat"};
Map map = new HashMap<>();
for (String word : words) {
  char[] chars = word.toCharArray();
  String key = new String(chars);
  Arrays.sort(chars);
  map.putIfAbsent(key, new ArrayList<>());
  map.get(key).add(word);
}
System.out.println(map.values());

medium

A. Sorting is done after creating the key, so keys are incorrect

B. Using putIfAbsent instead of computeIfAbsent causes error

C. The map should use List<Integer> instead of List<String>

D. The loop should use a while instead of for

Solution

1. Step 1: Check order of sorting and key creation

   Key is created from chars before sorting, so key is unsorted word.

2. Step 2: Identify impact on grouping

   Since keys are unsorted, anagrams get different keys and won't group correctly.

3. Final Answer:

   Sorting is done after creating the key, so keys are incorrect -> Option A

4. Quick Check:

   Sort before key creation to group correctly [OK]

Hint: Sort chars before creating key string [OK]

Common Mistakes:

• Creating key before sorting chars
• Confusing putIfAbsent with computeIfAbsent
• Wrong map value type

5. Given a list of words, how would you modify the grouping anagrams approach to handle case-insensitive grouping (e.g., "Eat" and "tea" are anagrams)?

hard

A. Use the original word as key without any change

B. Convert each word to lowercase before sorting and using as key

C. Group words by their length only

D. Sort words but keep original case for keys

Solution

1. Step 1: Understand case-insensitive grouping

   To treat "Eat" and "tea" as same group, ignore case by converting all words to lowercase.

2. Step 2: Apply lowercase conversion before sorting

   Convert word to lowercase, then sort chars to create key. This ensures case differences don't split groups.

3. Step 3: Group words using lowercase sorted keys

   Use these keys in hash map to group anagrams regardless of original case.

4. Final Answer:

   Convert each word to lowercase before sorting and using as key -> Option B

5. Quick Check:

   Lowercase + sort = case-insensitive grouping [OK]

Hint: Lowercase words before sorting for case-insensitive groups [OK]

Common Mistakes:

• Not converting to lowercase before sorting
• Using original case keys causing split groups
• Grouping by length instead of letters