You see a problem that says "group anagrams together" or "group strings by pattern." You know you need to categorize things... but what do you use as the key?
Should you sort the string? Use a character count? A hash? How do you store multiple items per group?
This is the gap between knowing you need to group and mastering the grouping pattern.
The grouping pattern is one of the most elegant hash map techniques. It appears in 30+ LeetCode problems, from "Group Anagrams" to "Group Shifted Strings" to custom categorization problems. But the pattern isn't just "make a dict"—it's a systematic approach to choosing grouping keys and aggregating data.
This guide will teach you:
Master this, and "group by" problems become pattern recognition.
The grouping pattern uses a hash map to categorize elements by a computed property, collecting all elements that share that property together.
Structure:
Example:
words = ["eat", "tea", "tan", "ate", "nat", "bat"]
# Group by sorted characters
groups = {
"aet": ["eat", "tea", "ate"],
"ant": ["tan", "nat"],
"abt": ["bat"]
}Without hash map (brute force):
# Compare every pair - O(n²)
for i in range(len(words)):
for j in range(i+1, len(words)):
if are_anagrams(words[i], words[j]):
# group themWith hash map:
# Compute key once per word - O(n)
groups = defaultdict(list)
for word in words:
key = compute_key(word) # e.g., sorted(word)
groups[key].append(word)Trade-off: Spend O(n) space to save O(n²) → O(n) time.
Imagine organizing books in a library:
The key is choosing the right categorization scheme.
This is the most critical decision in the grouping pattern.
A good grouping key must be:
# Group anagrams
key = ''.join(sorted(word))
"eat" → "aet"
"tea" → "aet" # Same key!
"tan" → "ant"Pros: Simple, works for any characters
Cons: O(k log k) per word where k = word length
# Group anagrams (faster for long words)
from collections import Counter
key = tuple(sorted(Counter(word).items()))
# Or for lowercase English only:
count = [0] * 26
for char in word:
count[ord(char) - ord('a')] += 1
key = tuple(count)Pros: O(k) per word, faster for long words
Cons: More complex, only works for known alphabet
# Group isomorphic strings
def get_pattern(s):
mapping = {}
pattern = []
next_id = 0
for char in s:
if char not in mapping:
mapping[char] = next_id
next_id += 1
pattern.append(str(mapping[char]))
return ','.join(pattern)
"egg" → "0,1,1"
"add" → "0,1,1" # Same pattern!
"foo" → "0,1,1" # Same pattern!
"bar" → "0,1,2" # Different patternPros: Captures structure
Cons: More complex to compute
# Group by multiple properties
key = (item.category, item.size, item.color)
# Example: Group points by (row, column sum)
key = (point.row, sum(point.columns))Pros: Flexible, handles multiple criteria
Cons: Need to ensure all parts are hashable
# Prime number product (for anagrams, risky)
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
def get_hash(word):
result = 1
for char in word:
result *= primes[ord(char) - ord('a')]
return resultPros: O(k) time, compact
Cons: Risk of overflow, only for small alphabets
What are you grouping?
├─ Anagrams → Sorted string or character count
├─ Isomorphic/pattern → Pattern string
├─ By multiple properties → Tuple
├─ Custom similarity → Custom hash function
└─ Unknown → Start with sorted/tupleFor more on key selection, see Hash Map Key Selection Guide.
from collections import defaultdict
def groupItems(items):
"""
Group items by computed key.
Time: O(n * k) where k = key computation time
Space: O(n)
"""
groups = defaultdict(list)
for item in items:
key = compute_key(item)
groups[key].append(item)
return list(groups.values())Why defaultdict?
def groupItems(items):
groups = {}
for item in items:
key = compute_key(item)
if key not in groups:
groups[key] = []
groups[key].append(item)
return list(groups.values())When to use: When you need more control or want to avoid defaultdict import.
import java.util.*;
public List<List<String>> groupItems(String[] items) {
Map<String, List<String>> groups = new HashMap<>();
for (String item : items) {
String key = computeKey(item);
groups.putIfAbsent(key, new ArrayList<>());
groups.get(key).add(item);
// Or use computeIfAbsent (Java 8+)
// groups.computeIfAbsent(key, k -> new ArrayList<>()).add(item);
}
return new ArrayList<>(groups.values());
}function groupItems(items) {
const groups = new Map();
for (const item of items) {
const key = computeKey(item);
if (!groups.has(key)) {
groups.set(key, []);
}
groups.get(key).push(item);
}
return Array.from(groups.values());
}Problem: Given an array of strings, group the anagrams together.
Input: ["eat", "tea", "tan", "ate", "nat", "bat"]
Output: [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]
from collections import defaultdict
def groupAnagrams(strs: List[str]) -> List[List[str]]:
groups = defaultdict(list)
for word in strs:
# Sorted string is the key
key = ''.join(sorted(word))
groups[key].append(word)
return list(groups.values())Complexity: O(n * k log k) where n = number of words, k = max word length
Trace:
word="eat" → key="aet" → groups={"aet": ["eat"]}
word="tea" → key="aet" → groups={"aet": ["eat", "tea"]}
word="tan" → key="ant" → groups={"aet": ["eat", "tea"], "ant": ["tan"]}
word="ate" → key="aet" → groups={"aet": ["eat", "tea", "ate"], "ant": ["tan"]}
word="nat" → key="ant" → groups={"aet": ["eat", "tea", "ate"], "ant": ["tan", "nat"]}
word="bat" → key="abt" → groups={"aet": ["eat", "tea", "ate"], "ant": ["tan", "nat"], "abt": ["bat"]}from collections import defaultdict
def groupAnagrams(strs: List[str]) -> List[List[str]]:
groups = defaultdict(list)
for word in strs:
# Count characters (only for lowercase English)
count = [0] * 26
for char in word:
count[ord(char) - ord('a')] += 1
# Tuple of counts is the key
key = tuple(count)
groups[key].append(word)
return list(groups.values())Complexity: O(n * k) where n = number of words, k = max word length
When to use: When words are long and alphabet is small (lowercase English).
from collections import defaultdict, Counter
def groupAnagrams(strs: List[str]) -> List[List[str]]:
groups = defaultdict(list)
for word in strs:
# Counter as key (need to convert to hashable)
key = tuple(sorted(Counter(word).items()))
groups[key].append(word)
return list(groups.values())Complexity: O(n * k) for counting, but sorting items adds overhead
For deep dive on all approaches, see Group Anagrams Deep Dive.
Problem: Determine if two strings are isomorphic (same pattern).
Examples:
def isIsomorphic(s: str, t: str) -> bool:
def get_pattern(string):
mapping = {}
pattern = []
next_id = 0
for char in string:
if char not in mapping:
mapping[char] = next_id
next_id += 1
pattern.append(mapping[char])
return tuple(pattern)
return get_pattern(s) == get_pattern(t)Key insight: Convert both strings to pattern, compare patterns.
Problem: Check if a pattern matches a sequence of words.
Example: pattern = "abba", s = "dog cat cat dog" → true
def wordPattern(pattern: str, s: str) -> bool:
words = s.split()
if len(pattern) != len(words):
return False
# Need bidirectional mapping
char_to_word = {}
word_to_char = {}
for char, word in zip(pattern, words):
if char in char_to_word:
if char_to_word[char] != word:
return False
else:
char_to_word[char] = word
if word in word_to_char:
if word_to_char[word] != char:
return False
else:
word_to_char[word] = char
return TrueKey insight: Need bidirectional mapping (both directions must be consistent).
Problem: Group strings that can be shifted to match each other.
Example: "abc", "bcd", "xyz" → all shift by same amount
from collections import defaultdict
def groupStrings(strings: List[str]) -> List[List[str]]:
def get_shift_key(s):
# Compute shift pattern relative to first character
if not s:
return ()
shifts = []
for i in range(1, len(s)):
shift = (ord(s[i]) - ord(s[i-1])) % 26
shifts.append(shift)
return tuple(shifts)
groups = defaultdict(list)
for s in strings:
key = get_shift_key(s)
groups[key].append(s)
return list(groups.values())Key insight: Compute relative shifts between adjacent characters.
Problem: Group numbers by sum of their digits.
from collections import defaultdict
def groupByDigitSum(nums: List[int]) -> List[List[int]]:
def digit_sum(n):
total = 0
while n:
total += n % 10
n //= 10
return total
groups = defaultdict(list)
for num in nums:
key = digit_sum(num)
groups[key].append(num)
return list(groups.values())Pattern: Group by computed property (sum of digits).
Sometimes you need to group by multiple properties.
from collections import defaultdict
def groupByLengthAndFirst(words: List[str]) -> List[List[str]]:
groups = defaultdict(list)
for word in words:
# Tuple of (length, first char)
key = (len(word), word[0] if word else '')
groups[key].append(word)
return list(groups.values())
# Example
words = ["apple", "ant", "banana", "bat", "cat"]
# Groups: {(5, 'a'): ["apple"], (3, 'a'): ["ant"], (6, 'b'): ["banana"], (3, 'b'): ["bat"], (3, 'c'): ["cat"]}from collections import defaultdict
def groupPoints(points: List[List[int]]) -> List[List[List[int]]]:
groups = defaultdict(list)
for point in points:
row, col = point
# Group by (row, sum of coordinates)
key = (row, row + col)
groups[key].append(point)
return list(groups.values())Key insight: Use tuple of properties as key.
❌ Wrong (lists are not hashable):
key = [item.x, item.y] # Can't use list as key!
groups[key].append(item) # TypeError!✅ Correct (use tuple):
key = (item.x, item.y) # Tuple is hashable
groups[key].append(item)Sometimes you need to aggregate data after grouping.
from collections import defaultdict
def sumByCategory(items: List[Tuple[str, int]]) -> Dict[str, int]:
# items = [("fruit", 10), ("veg", 5), ("fruit", 20), ("veg", 15)]
sums = defaultdict(int)
for category, value in items:
sums[category] += value
return dict(sums)
# {"fruit": 30, "veg": 20}from collections import defaultdict
def countByGroup(items: List[str]) -> Dict[str, int]:
counts = defaultdict(int)
for item in items:
key = compute_key(item)
counts[key] += 1
return dict(counts)from collections import defaultdict
def maxByGroup(items: List[Tuple[str, int]]) -> Dict[str, int]:
maxes = defaultdict(lambda: float('-inf'))
for category, value in items:
maxes[category] = max(maxes[category], value)
return dict(maxes)❌ Wrong:
# Lists are not hashable
key = sorted(word) # Returns list!
groups[key].append(word) # TypeError!✅ Correct:
# Convert to string or tuple
key = ''.join(sorted(word)) # String
# Or
key = tuple(sorted(word)) # Tuple
groups[key].append(word)❌ Wrong (for anagrams):
# Using first character as key
key = word[0]
# "eat" and "egg" would be in same group!✅ Correct:
# Use sorted characters
key = ''.join(sorted(word))❌ Wrong:
key = word[0] # Crashes if word is empty!✅ Correct:
key = word[0] if word else ''
# Or check before
if not word:
continue❌ Wrong (returns dict_values):
return groups.values() # Returns dict_values object✅ Correct:
return list(groups.values()) # Convert to listBuilding groups: O(n * k) where k = key computation time
Total:
Groups storage: O(n)
Keys storage: O(g) where g = number of groups
The grouping pattern is a powerful technique for categorizing data by computed properties.
Key principles:
The template:
from collections import defaultdict
groups = defaultdict(list)
for item in items:
key = compute_key(item)
groups[key].append(item)
return list(groups.values())Common key types:
When to use:
Common mistakes:
Next steps:
Master grouping, and categorization problems become pattern recognition.
LeetCopilot is a free browser extension that enhances your LeetCode practice with AI-powered hints, personalized study notes, and realistic mock interviews — all designed to accelerate your coding interview preparation.
Also compatible with Edge, Brave, and Opera
Add to Chrome for free