Unique Occurrences LeetCode 1207 Guide

LeetCode 1207 gives you an integer array arr and asks you to return true if the number of occurrences of each value in the array is unique — meaning no two distinct values share the same frequency count. If any two values appear the same number of times, return false.

For example, arr=[1,2,2,1,1,3] has value 1 appearing 3 times, value 2 appearing 2 times, and value 3 appearing 1 time. The frequency set is {3, 2, 1} — all distinct — so the answer is true. Contrast with arr=[1,2] where both values appear once: frequencies {1, 1} are not all unique, so the answer is false.

The problem is straightforward once you identify the two-step structure: first build a frequency map, then verify the frequencies themselves are all distinct. The constraints are small enough that any reasonable approach works well.

The solution breaks into two independent steps. Step 1: count the frequency of every value in the array using a hash map or Counter. After this pass, you have a dictionary mapping each distinct value to the number of times it appears.

Step 2: check whether all the frequency counts are unique. Extract the values (counts) from the frequency map and place them in a set. If the set size equals the number of distinct values (the map size), every frequency was unique — return true. If the set is smaller, some counts were duplicated — return false.

This two-step decomposition is clean and general: any time you need to verify a property about frequencies rather than values themselves, build the frequency map first, then apply the property check to the map's values.

Counter(arr) builds a dictionary mapping each unique value to its occurrence count. For arr=[1,2,2,1,1,3], Counter produces {1:3, 2:2, 3:1}. The map has 3 keys — one for each distinct value in the array.

Taking set(counts.values()) converts the collection of frequency numbers [3, 2, 1] into a set {3, 2, 1}. A set discards duplicates, so if any two frequencies were equal the set would be smaller than the original list. Comparing len(counts) == len(set(counts.values())) captures this exactly: equal lengths mean no duplicates were discarded.

This works because Counter guarantees every key maps to a positive integer count, so the values list is non-empty and well-defined. The set comparison is O(k) where k is the number of distinct values — typically much smaller than n.

Instead of a set, you can sort the frequency values and scan for adjacent duplicates. After building the frequency map, extract the values into a list, sort it, and iterate through adjacent pairs. If any pair is equal, the frequencies are not all unique — return false. If you reach the end without finding a duplicate, return true.

This approach is O(n log n) in the worst case due to sorting, compared to O(n) for the set approach. In practice, k (the number of distinct values) is bounded by min(n, 2001) given the constraints, so sorting is at most O(2001 log 2001) — effectively constant. Both approaches are perfectly valid for this problem size.

The sorting approach may be slightly more intuitive if you think of the problem as "are there repeated elements in this list?" — a classic duplicate-detection pattern. The set approach is more idiomatic in Python and Java and is the preferred one-liner solution.

Example 1: arr=[1,2,2,1,1,3]. Count frequencies: Counter gives {1:3, 2:2, 3:1}. Frequency values list: [3, 2, 1]. Set of frequencies: {3, 2, 1}. len([3,2,1]) = 3 == len({3,2,1}) = 3 → true. All three values have distinct occurrence counts.

Example 2: arr=[1,2]. Count frequencies: Counter gives {1:1, 2:1}. Frequency values list: [1, 1]. Set of frequencies: {1}. len([1,1]) = 2 != len({1}) = 1 → false. Both values appear exactly once, so the occurrence counts are not unique.

Example 3: arr=[3,3,3,5,5] → Counter gives {3:3, 5:2} → values [3, 2] → set {3, 2} → 2 == 2 → true. Now add a 5: arr=[3,3,3,5,5,5] → {3:3, 5:3} → values [3,3] → set {3} → 2 != 1 → false.

Python one-liner: from collections import Counter; return len(counts := Counter(arr)) == len(set(counts.values())). The walrus operator assigns Counter(arr) to counts inline, then compares map size to set-of-values size. A slightly more readable version: counts = Counter(arr); return len(counts) == len(set(counts.values())).

Java solution: use a HashMap<Integer, Integer> to count frequencies. Iterate arr and call map.merge(num, 1, Integer::sum) for each element. Then collect values into a HashSet<Integer> and compare sizes: return map.size() == new HashSet<>(map.values()).size(). Both the HashMap and HashSet operations are O(n) time and O(n) space.

Both Python and Java solutions run in O(n) time and O(n) space. The dominant cost is the linear scan to build the frequency map. Set construction from k values is O(k) and k <= n, so the overall complexity is O(n). Space is O(k) for the map and O(k) for the set.

LeetCode 1207 belongs to the frequency-checking family. Valid Anagram (LeetCode 242) also builds a character frequency map and compares it — but checks if two maps are equal rather than checking for unique counts. Ransom Note (LeetCode 383) checks if one frequency map is a subset of another.

Two Strings Close (LeetCode 1657) is the most closely related: it requires that the sorted frequency multisets of two strings are equal — essentially the same "compare frequency lists" idea extended to checking equality between two strings. Group Anagrams (LeetCode 49) groups strings by their sorted frequency signature.

The broader frequency-uniqueness pattern appears whenever a problem asks you to reason about how often things occur rather than what they are. Build the frequency map first, then apply your check to the map's values — this two-level thinking (values → frequencies → property of frequencies) is a recurring idiom in hash map problems.