Loading…

easyBasicsSometimes asked

Frequency of Elements

Basics · 6 min

Given an integer array nums, return a map from each value to how many times it appears.

In plain English

A hash map keyed by value, incrementing the count for each element.

Examples

Example 1

Input: nums = [1, 2, 2, 3]
Output: {1:1, 2:2, 3:1}
Note: Counts per value.

Example 2

Input: nums = [5, 5, 5]
Output: {5:3}
Note: One key.

Example 3

Input: nums = []
Output: {}
Note: Empty map.

Constraints

0 ≤ nums.length ≤ 10^5

Clarifying questions1First question: Return a map or sorted counts?Explore questions

Q1.Return a map or sorted counts?
A value→count map; I can post-process for top-K or sorting.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Iterate once, doing `count[x] = count.getOrDefault(x, 0) + 1`. The map is the frequency table. O(n) time, O(k) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you reach for a frequency map and handle the first-sighting default.

Where candidates slip

NPE on missing key, or an O(n²) count-per-value loop.

How to stand out

Name the downstream problems (anagram, top-K, majority) this map unlocks.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Hash map counting

TimeO(n)SpaceO(k)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What structure maps a value to a running count?

2Hint 2Explore hint

Increment count[x], defaulting to 0 for first sightings.

3Hint 3Explore hint

This same map powers anagrams, top-K, and majority element.

A · Core idea

Build a frequency map: a hash map from each value to its count, filled in a single pass with count[x] = count.getOrDefault(x, 0) + 1. This table is the single most reused primitive from fresher problems all the way to hard ones.

Why getOrDefault / Counter. The first time you see a value it has no entry; getOrDefault(x, 0) (Java) or collections.Counter (Python) supplies the implicit 0 so you don't NullPointer or KeyError on first sight.

Why O(n) time, O(k) space. One pass over n elements, each an O(1) map update; the map holds k distinct keys, so space is O(k) ≤ O(n).

Why it matters. Anagram checks, top-K frequent, majority element, group-by, and first-unique-character all reduce to building this map first. Learn the increment idiom cold and a whole family of problems opens up.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 2, 3]

new → 1

State{1:1}

Final result{1:1, 2:2, 3:1}

C · Code with teaching comments

solution.javaJava

Hash map counting — optimal

1 teaching note

1
public java.util.Map<Integer, Integer> frequency(int[] nums) {
2
    java.util.Map<Integer, Integer> freq = new java.util.HashMap<>();
3
    for (int x : nums) {
4
        // Increment the bucket, defaulting to 0 for first sightings.
5
        freq.put(x, freq.getOrDefault(x, 0) + 1);
6
    }
7
    return freq;
8
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.8 lines

D · Why it works and complexityO(n) timeO(k) spaceOpen the invariant and proofExplore the proof

This single building block unlocks a huge family of harder problems — learn it cold.

ComplexityO(n) time, O(k) space — one O(1) map update per element (O(n) total); the map stores k ≤ n distinct keys.

E · Edge cases and pitfalls4nums = [5, 5, 5] — Single key → {5:3}.Explore edge cases

Edge cases handled

nums = [5, 5, 5]Single key → {5:3}.
nums = []Empty map {}.

Pitfalls

Forgetting the default for a first appearance (NullPointerException in Java).
Scanning a list per value (O(n²)) instead of one map pass.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic java.util.Map<Integer, Integer> frequency(int[] nums) { java.util.Map<Integer, Integer> freq = new java.util.HashMap<>(); for (int x : nums) { freq.put(x, freq.getOrDefault(x, 0) + 1); }Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

No default on first sight

`freq.get(x) + 1` throws when x is absent (null in Java). Use getOrDefault / Counter so first sightings start at 0.

Explore the code comparison

Don't write this

freq.put(x, freq.get(x) + 1);            // NPE when x is new

Write this instead

freq.put(x, freq.getOrDefault(x, 0) + 1);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Frequency map

Code pattern to memorize

for x: freq[x] = freq.get(x,0) + 1

Rules to remember

1Key = value, value = count.
2getOrDefault for first sighting.
3Foundation for anagram/top-K.

Use this pattern when

Counting, anagrams, top-K, majority, group-by

Interview takeaway

The frequency map is the most reused fresher-to-advanced primitive.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Frequency map. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Valid Anagram
Compare two frequency maps (or one with +/−).
Top K Frequent Elements
Coming soon
Build this map, then bucket/heap by count.

Same pattern

easyBasicsSometimes asked

Frequency of Elements

Basics · 6 min

Given an integer array nums, return a map from each value to how many times it appears.

In plain English

A hash map keyed by value, incrementing the count for each element.

Examples

Example 1

Input: nums = [1, 2, 2, 3]
Output: {1:1, 2:2, 3:1}
Note: Counts per value.

Example 2

Input: nums = [5, 5, 5]
Output: {5:3}
Note: One key.

Example 3

Input: nums = []
Output: {}
Note: Empty map.

Constraints

0 ≤ nums.length ≤ 10^5

Clarifying questions1First question: Return a map or sorted counts?Explore questions

Q1.Return a map or sorted counts?
A value→count map; I can post-process for top-K or sorting.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Iterate once, doing `count[x] = count.getOrDefault(x, 0) + 1`. The map is the frequency table. O(n) time, O(k) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you reach for a frequency map and handle the first-sighting default.

Where candidates slip

NPE on missing key, or an O(n²) count-per-value loop.

How to stand out

Name the downstream problems (anagram, top-K, majority) this map unlocks.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 1 · Optimal

Hash map counting

TimeO(n)SpaceO(k)

This is the standard, expected solution — lead with it.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

What structure maps a value to a running count?

2Hint 2Explore hint

Increment count[x], defaulting to 0 for first sightings.

3Hint 3Explore hint

This same map powers anagrams, top-K, and majority element.

A · Core idea

Why O(n) time, O(k) space. One pass over n elements, each an O(1) map update; the map holds k distinct keys, so space is O(k) ≤ O(n).

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

nums = [1, 2, 2, 3]

new → 1

State{1:1}

Final result{1:1, 2:2, 3:1}

C · Code with teaching comments

solution.javaJava

Hash map counting — optimal

1 teaching note

1
public java.util.Map<Integer, Integer> frequency(int[] nums) {
2
    java.util.Map<Integer, Integer> freq = new java.util.HashMap<>();
3
    for (int x : nums) {
4
        // Increment the bucket, defaulting to 0 for first sightings.
5
        freq.put(x, freq.getOrDefault(x, 0) + 1);
6
    }
7
    return freq;
8
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.8 lines

D · Why it works and complexityO(n) timeO(k) spaceOpen the invariant and proofExplore the proof

This single building block unlocks a huge family of harder problems — learn it cold.

ComplexityO(n) time, O(k) space — one O(1) map update per element (O(n) total); the map stores k ≤ n distinct keys.

E · Edge cases and pitfalls4nums = [5, 5, 5] — Single key → {5:3}.Explore edge cases

Edge cases handled

nums = [5, 5, 5]Single key → {5:3}.
nums = []Empty map {}.

Pitfalls

Forgetting the default for a first appearance (NullPointerException in Java).
Scanning a list per value (O(n²)) instead of one map pass.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

No default on first sight

`freq.get(x) + 1` throws when x is absent (null in Java). Use getOrDefault / Counter so first sightings start at 0.

Explore the code comparison

Don't write this

freq.put(x, freq.get(x) + 1);            // NPE when x is new

Write this instead

freq.put(x, freq.getOrDefault(x, 0) + 1);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Frequency map

Code pattern to memorize

for x: freq[x] = freq.get(x,0) + 1

Rules to remember

1Key = value, value = count.
2getOrDefault for first sighting.
3Foundation for anagram/top-K.

Use this pattern when

Counting, anagrams, top-K, majority, group-by

Interview takeaway

The frequency map is the most reused fresher-to-advanced primitive.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternA core fresher pattern: Frequency map. Master it on small inputs and it transfers to harder problems.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Valid Anagram
Compare two frequency maps (or one with +/−).
Top K Frequent Elements
Coming soon
Build this map, then bucket/heap by count.

Same pattern