You see a problem that asks you to "count occurrences" or "find the most frequent element." You know you need to count things... but then what?
Do you use a Counter? A dict? How do you find the top-k most frequent elements efficiently? What if you need to count and then do something with those counts?
This is the gap between knowing how to count and mastering the frequency counter pattern.
The frequency counter is one of the most versatile hash map patterns. It appears in 50+ LeetCode problems, from easy "Valid Anagram" to hard "Top K Frequent Elements." But the pattern isn't just Counter(arr)—it's a systematic approach to counting, querying, and optimizing based on frequencies.
This guide will teach you:
Master this, and frequency problems become pattern recognition, not guesswork.
The frequency counter pattern uses a hash map to count how many times each element appears, then uses those counts to make decisions or find answers.
Structure:
Example:
arr = [1, 2, 2, 3, 3, 3]
freq = {1: 1, 2: 2, 3: 3}Counting with a hash map is O(n) time, O(k) space where k = number of distinct elements.
Without hash map:
# Count how many times 3 appears - O(n) per query
count = sum(1 for x in arr if x == 3)With hash map:
# Build once - O(n)
freq = Counter(arr)
# Query - O(1)
count = freq[3]Imagine counting votes in an election:
Use frequency counter when:
Strong frequency counter signals:
vs. Hash Set:
vs. Sorting:
vs. Array counting:
from collections import Counter
# Build frequency counter
freq = Counter(arr)
# Access count
count = freq[element] # Returns 0 if not found
# Most common
most_common = freq.most_common(k) # Returns [(elem, count), ...]
# Example
arr = ['a', 'b', 'a', 'c', 'a', 'b']
freq = Counter(arr)
print(freq) # Counter({'a': 3, 'b': 2, 'c': 1})
print(freq.most_common(2)) # [('a', 3), ('b', 2)]Pros: Clean, built-in, has useful methods
Cons: Slightly more memory overhead
# Build frequency counter
freq = {}
for elem in arr:
freq[elem] = freq.get(elem, 0) + 1
# Or with setdefault
freq = {}
for elem in arr:
freq.setdefault(elem, 0)
freq[elem] += 1Pros: More control, slightly faster
Cons: More verbose
from collections import defaultdict
freq = defaultdict(int)
for elem in arr:
freq[elem] += 1Pros: Clean, no need for .get()
Cons: Returns 0 for missing keys (can be surprising)
Recommendation: Use Counter for interviews (clearest intent).
import java.util.*;
// Build frequency counter
Map<Character, Integer> freq = new HashMap<>();
for (char c : s.toCharArray()) {
freq.put(c, freq.getOrDefault(c, 0) + 1);
}
// Access count
int count = freq.getOrDefault(c, 0);
// Find most frequent (manual)
int maxFreq = 0;
char mostFrequent = ' ';
for (Map.Entry<Character, Integer> entry : freq.entrySet()) {
if (entry.getValue() > maxFreq) {
maxFreq = entry.getValue();
mostFrequent = entry.getKey();
}
}// Using Map
const freq = new Map();
for (const elem of arr) {
freq.set(elem, (freq.get(elem) || 0) + 1);
}
// Access count
const count = freq.get(elem) || 0;
// Find most frequent
let maxFreq = 0;
let mostFrequent = null;
for (const [elem, count] of freq.entries()) {
if (count > maxFreq) {
maxFreq = count;
mostFrequent = elem;
}
}
// Using object (for simple keys)
const freq = {};
for (const elem of arr) {
freq[elem] = (freq[elem] || 0) + 1;
}Use case: Compare if two collections have the same frequencies.
Problem: Given two strings s and t, return true if t is an anagram of s.
Insight: Anagrams have identical character frequencies.
from collections import Counter
def isAnagram(s: str, t: str) -> bool:
return Counter(s) == Counter(t)Complexity: O(n) time, O(k) space where k = alphabet size
def isAnagram(s: str, t: str) -> bool:
if len(s) != len(t):
return False
freq = Counter(s)
for char in t:
if char not in freq:
return False
freq[char] -= 1
if freq[char] < 0:
return False
return TrueOptimization: Slightly more memory efficient (one counter instead of two).
def isAnagram(s: str, t: str) -> bool:
if len(s) != len(t):
return False
# Only for lowercase English letters
count = [0] * 26
for char in s:
count[ord(char) - ord('a')] += 1
for char in t:
count[ord(char) - ord('a')] -= 1
if count[ord(char) - ord('a')] < 0:
return False
return all(c == 0 for c in count)When to use: Only if alphabet is small and known (a-z, 0-9).
Problem: Find all start indices of anagrams of p in string s.
Pattern: Frequency counter + sliding window
from collections import Counter
def findAnagrams(s: str, p: str) -> List[int]:
if len(p) > len(s):
return []
result = []
p_count = Counter(p)
window_count = Counter(s[:len(p)])
if window_count == p_count:
result.append(0)
# Slide window
for i in range(len(p), len(s)):
# Add new character
window_count[s[i]] += 1
# Remove old character
left_char = s[i - len(p)]
window_count[left_char] -= 1
if window_count[left_char] == 0:
del window_count[left_char]
# Check if anagram
if window_count == p_count:
result.append(i - len(p) + 1)
return resultKey insight: Combine frequency counter with sliding window for efficiency.
Use case: Find elements with highest/lowest frequency.
Problem: Given an integer array nums and an integer k, return the k most frequent elements.
from collections import Counter
import heapq
def topKFrequent(nums: List[int], k: int) -> List[int]:
# Count frequencies
freq = Counter(nums)
# Use heap to find top k
return heapq.nlargest(k, freq.keys(), key=freq.get)Complexity: O(n + k log n) time, O(n) space
from collections import Counter
def topKFrequent(nums: List[int], k: int) -> List[int]:
freq = Counter(nums)
return [num for num, count in freq.most_common(k)]Complexity: O(n + k log n) time (uses heap internally)
from collections import Counter
def topKFrequent(nums: List[int], k: int) -> List[int]:
freq = Counter(nums)
# Bucket sort: bucket[i] = elements with frequency i
buckets = [[] for _ in range(len(nums) + 1)]
for num, count in freq.items():
buckets[count].append(num)
# Collect top k from highest frequency buckets
result = []
for i in range(len(buckets) - 1, 0, -1):
result.extend(buckets[i])
if len(result) >= k:
return result[:k]
return resultComplexity: O(n) time, O(n) space (optimal!)
When to use each:
from collections import Counter
def frequencySort(s: str) -> str:
freq = Counter(s)
# Sort by frequency (descending), then by character (for tie-breaking)
sorted_chars = sorted(freq.items(), key=lambda x: (-x[1], x[0]))
# Build result
result = []
for char, count in sorted_chars:
result.append(char * count)
return ''.join(result)Alternative (bucket sort):
def frequencySort(s: str) -> str:
freq = Counter(s)
buckets = [[] for _ in range(len(s) + 1)]
for char, count in freq.items():
buckets[count].append(char)
result = []
for i in range(len(buckets) - 1, 0, -1):
for char in buckets[i]:
result.append(char * i)
return ''.join(result)Use case: Check if frequencies meet specific conditions.
Problem: Find the first non-repeating character in a string.
from collections import Counter
def firstUniqChar(s: str) -> int:
freq = Counter(s)
# Find first character with frequency 1
for i, char in enumerate(s):
if freq[char] == 1:
return i
return -1Key insight: Build frequency map first, then iterate to find first unique.
Problem: Find the element that appears more than ⌊n/2⌋ times.
from collections import Counter
def majorityElement(nums: List[int]) -> int:
freq = Counter(nums)
n = len(nums)
for num, count in freq.items():
if count > n // 2:
return numComplexity: O(n) time, O(n) space
def majorityElement(nums: List[int]) -> int:
candidate = None
count = 0
for num in nums:
if count == 0:
candidate = num
count += 1 if num == candidate else -1
return candidateComplexity: O(n) time, O(1) space (optimal!)
When to use:
from collections import Counter
def areOccurrencesEqual(s: str) -> bool:
freq = Counter(s)
counts = list(freq.values())
return len(set(counts)) == 1Insight: All frequencies should be the same → set of frequencies has size 1.
Combining frequency counter with sliding window is powerful for substring problems.
Problem: Check if s2 contains a permutation of s1.
from collections import Counter
def checkInclusion(s1: str, s2: str) -> bool:
if len(s1) > len(s2):
return False
s1_count = Counter(s1)
window_count = Counter(s2[:len(s1)])
if window_count == s1_count:
return True
# Slide window
for i in range(len(s1), len(s2)):
# Add new character
window_count[s2[i]] += 1
# Remove old character
left_char = s2[i - len(s1)]
window_count[left_char] -= 1
if window_count[left_char] == 0:
del window_count[left_char]
if window_count == s1_count:
return True
return FalsePattern: Fixed-size sliding window + frequency comparison.
For more on this combination, see Hash Map in Sliding Window.
❌ Wrong:
freq = {}
for char in s:
freq[char] += 1 # KeyError if char not in freq!✅ Correct:
# Option 1: Use .get()
freq = {}
for char in s:
freq[char] = freq.get(char, 0) + 1
# Option 2: Use Counter
from collections import Counter
freq = Counter(s)
# Option 3: Use defaultdict
from collections import defaultdict
freq = defaultdict(int)
for char in s:
freq[char] += 1❌ Wrong:
# Comparing lists of values (order matters!)
freq1 = Counter(s1)
freq2 = Counter(s2)
return list(freq1.values()) == list(freq2.values()) # Wrong!✅ Correct:
# Compare Counter objects directly
return Counter(s1) == Counter(s2)❌ Wrong:
# In sliding window, leaving zero counts
window_count[left_char] -= 1
# Now window_count might have {char: 0}, which != Counter without that char✅ Correct:
window_count[left_char] -= 1
if window_count[left_char] == 0:
del window_count[left_char]❌ Wrong:
# Assuming only lowercase letters, but input has uppercase too
count = [0] * 26 # Only handles a-z!✅ Correct:
# Use Counter for general case
freq = Counter(s)Rule: Only use array counting when alphabet is small and known.
Building frequency counter: O(n)
Querying frequency: O(1)
Finding top-k:
Frequency counter: O(k) where k = number of distinct elements
Practical consideration: For strings with limited alphabet (a-z), space is O(26) = O(1).
The frequency counter pattern is a fundamental hash map technique for counting and querying element occurrences.
Key principles:
The template:
from collections import Counter
# Build
freq = Counter(arr)
# Query
count = freq[element]
# Top k
top_k = freq.most_common(k)When to use:
Common mistakes:
Next steps:
Master frequency counters, and counting 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