Group Anagrams - Practice Coding Problems

Group Anagrams - Problem

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Input & Output

Example 1 — Basic Anagram Grouping

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

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

💡 Note: eat, tea, ate contain same letters (a,e,t). tan, nat contain same letters (a,n,t). bat stands alone with letters (a,b,t).

Example 2 — Empty String

$ Input: strs = [""]

› Output: [[""]]

💡 Note: Single empty string forms one group by itself.

Example 3 — Single Character

$ Input: strs = ["a"]

› Output: [["a"]]

💡 Note: Single string with one character forms one group.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Array of strings that may be anagrams of each other

Process

Identify which strings are anagrams (same letters, different order)

Output

Groups of anagram strings in nested arrays

Key Takeaway

🎯 Key Insight: Anagrams have identical characters - sort each string's characters to create matching keys for grouping

Asked in

a Amazon 85 f Facebook 72 M Microsoft 68 G Google 54

The optimal approach is to sort characters in each string and use the sorted result as a hash map key. Anagrams will have identical sorted keys, allowing us to group them efficiently. Time: O(nm log m), Space: O(nm) where n is number of strings and m is average string length.

Common Approaches

Approach	Time	Space	Notes
✓ Sort Characters (Optimal)	O(nm log m)	O(nm)	Sort characters in each string and use sorted string as key to group anagrams
Character Frequency Count	O(nm)	O(nm)	Count character frequencies and use them as signatures to group anagrams
Brute Force	O(n²m)	O(nm)	Compare each string with every other string to check if they are anagrams

Sort Characters (Optimal) — Algorithm Steps

Sort characters in each string
Use sorted string as hash map key
Group strings with same sorted key
Return all groups as result

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort

Sort characters in each string alphabetically

Group

Use sorted strings as keys to group anagrams

Result

Return all anagram groups

Code -

solution.c — C

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

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

void getSortedKey(const char* s, char* sortedKey) {
    strcpy(sortedKey, s);
    qsort(sortedKey, strlen(sortedKey), sizeof(char), charCompare);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    char strs[100][100];
    char sortedKeys[100][100];
    int n = 0;
    
    char* token = strtok(line + 1, ",");
    while (token) {
        while (*token == ' ') token++;
        if (*token == '"') {
            token++;
            char* end = strrchr(token, '"');
            if (end) *end = '\0';
        }
        strcpy(strs[n], token);
        getSortedKey(token, sortedKeys[n]);
        n++;
        token = strtok(NULL, ",");
    }
    
    bool used[100] = {false};
    printf("[");
    bool firstGroup = true;
    
    for (int i = 0; i < n; i++) {
        if (used[i]) continue;
        
        if (!firstGroup) printf(",");
        printf("[");
        printf("\"%s\"", strs[i]);
        used[i] = true;
        
        for (int j = i + 1; j < n; j++) {
            if (!used[j] && strcmp(sortedKeys[i], sortedKeys[j]) == 0) {
                printf(",\"%s\"", strs[j]);
                used[j] = true;
            }
        }
        
        printf("]");
        firstGroup = false;
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(nm log m)

Process n strings, each requiring O(m log m) time to sort m characters

⚡ Linearithmic

Space Complexity

O(nm)

Hash map stores all strings grouped by sorted keys, requiring space for n strings of length m

⚡ Linearithmic Space

270.6K Views

High Frequency

~15 min Avg. Time

8.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Sort Characters (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler