Group Anagrams - Practice Coding Problems

Group Anagrams - Problem

Imagine you have a collection of words scattered around, and you need to organize them by their anagram groups. Two strings are anagrams if they contain the exact same characters with the same frequency, just rearranged differently.

Given an array of strings strs, your task is to group all anagrams together. Each group should contain strings that are anagrams of each other.

For example: ["eat", "tea", "tan", "ate", "nat", "bat"] should be grouped as [["eat","tea","ate"],["tan","nat"],["bat"]] because:

"eat", "tea", "ate" all contain the same characters: e, a, t
"tan", "nat" both contain: t, a, n
"bat" stands alone with: b, a, t

You can return the groups in any order, and the strings within each group can also be in any order.

Input & Output

example_1.py — Basic Grouping

$ Input: ["eat","tea","tan","ate","nat","bat"]

› Output: [["eat","tea","ate"],["tan","nat"],["bat"]]

💡 Note: Strings with the same characters are grouped together: 'eat', 'tea', and 'ate' all contain the same letters (e,a,t). Similarly, 'tan' and 'nat' contain (t,a,n). 'bat' forms its own group.

example_2.py — Single Characters

$ Input: ["a"]

› Output: [["a"]]

💡 Note: A single string forms one group by itself.

example_3.py — Empty String

$ Input: [""]

› Output: [[""]]

💡 Note: An empty string is its own anagram group.

Visualization

Tap to expand

Understanding the Visualization

Create Signatures

Sort each word's letters alphabetically to create a unique signature

Group by Signature

Words with the same signature are anagrams and belong together

Collect Results

Return all groups formed by this signature-based organization

Key Takeaway

🎯 Key Insight: Anagrams have identical character signatures when sorted alphabetically. By using sorted strings as hash map keys, we can efficiently group anagrams in O(n×m log m) time!

Time & Space Complexity

Time Complexity

⏱️

O(n×m log m)

n strings, each taking O(m log m) to sort where m is average string length

⚡ Linearithmic

Space Complexity

O(n×m)

Hash map stores all strings plus sorted keys

⚡ Linearithmic Space

Constraints

1 ≤ strs.length ≤ 10⁴
0 ≤ strs[i].length ≤ 100
strs[i] consists of lowercase English letters only

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a hash map with sorted character strings as keys. By sorting each string's characters, anagrams naturally map to the same key, allowing us to group them in O(n×m log m) time where n is the number of strings and m is the average string length. This approach is both intuitive and efficient for interview scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map with Sorted Keys (Optimal)	O(n×m log m)	O(n×m)	Use sorted string as key to group anagrams in a single pass
Brute Force (Compare Each Pair)	O(n²×m)	O(n×m)	Compare every string with every other string to check if they're anagrams

Hash Map with Sorted Keys (Optimal) — Algorithm Steps

Create an empty hash map to store groups
For each string, sort its characters to create a key
Use this key to group anagrams together in the hash map
Return all groups as a list of lists

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Characters

Convert each string to its canonical sorted form

Hash Mapping

Use sorted string as key to group anagrams

Build Groups

Collect all strings with the same canonical key

Return Results

Extract all groups from hash map

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int compare(const void* a, const void* b) {
    return (*(char*)a - *(char*)b);
}

char* getSortedKey(char* str) {
    int len = strlen(str);
    char* key = malloc((len + 1) * sizeof(char));
    strcpy(key, str);
    qsort(key, len, sizeof(char), compare);
    return key;
}

char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes) {
    // Simplified implementation for demonstration
    char*** result = malloc(strsSize * sizeof(char**));
    *returnColumnSizes = malloc(strsSize * sizeof(int));
    char** keys = malloc(strsSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < strsSize; i++) {
        keys[i] = getSortedKey(strs[i]);
    }
    
    bool* used = calloc(strsSize, sizeof(bool));
    
    for (int i = 0; i < strsSize; i++) {
        if (used[i]) continue;
        
        result[*returnSize] = malloc(strsSize * sizeof(char*));
        int groupSize = 0;
        
        for (int j = i; j < strsSize; j++) {
            if (!used[j] && strcmp(keys[i], keys[j]) == 0) {
                result[*returnSize][groupSize++] = strs[j];
                used[j] = true;
            }
        }
        
        (*returnColumnSizes)[*returnSize] = groupSize;
        (*returnSize)++;
    }
    
    for (int i = 0; i < strsSize; i++) {
        free(keys[i]);
    }
    free(keys);
    free(used);
    
    return result;
}

int main() {
    char* strs[] = {"eat", "tea", "tan", "ate", "nat", "bat"};
    int returnSize;
    int* returnColumnSizes;
    char*** result = groupAnagrams(strs, 6, &returnSize, &returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m log m)

n strings, each taking O(m log m) to sort where m is average string length

⚡ Linearithmic

Space Complexity

O(n×m)

Hash map stores all strings plus sorted keys

⚡ Linearithmic Space

Constraints

1 ≤ strs.length ≤ 10⁴
0 ≤ strs[i].length ≤ 100
strs[i] consists of lowercase English letters only

128.0K Views

High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map with Sorted Keys (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler