Is First Element with Unique Frequency easy or hard?

This problem is usually classified as Medium difficulty. The main challenge is recognizing that checking frequency uniqueness efficiently requires an additional frequency-of-frequency map rather than repeatedly scanning all counts.

First Element with Unique Frequency Python/Java solution

In Python, a dictionary or collections.Counter can track frequencies, followed by another dictionary for frequency counts. In Java, HashMap is typically used for both maps. The same logic applies in C++, Go, and TypeScript using their standard hash map structures.

How to solve First Element with Unique Frequency in O(n)?

Use a two-step counting approach. First create a hash map that stores how many times each number appears. Then build another map that counts how many numbers have each frequency. Finally iterate through the array and return the first element whose frequency count equals one.

What is the best approach for First Element with Unique Frequency?

The best approach uses two hash tables. First count the frequency of each element, then count how many elements share each frequency. After that, scan the array in its original order and return the first element whose frequency occurs exactly once. This runs in O(n) time with O(n) extra space.

Is First Element with Unique Frequency asked at Google/Amazon/Meta?

Frequency counting and hash map problems are common in interviews at companies like Amazon, Google, and Meta. Variations of this problem appear when testing understanding of hash tables, counting strategies, and handling order-sensitive array scans.

What data structure is used in First Element with Unique Frequency?

The primary data structure is a hash table (hash map). One map stores element frequencies, and another tracks how many elements share each frequency. Arrays are used for iteration order, while the hash maps provide constant-time lookups.

What is the time complexity of First Element with Unique Frequency?

The optimal solution runs in O(n) time. One pass builds the element frequency map, another pass builds the frequency-of-frequency map, and a final scan checks elements in order. Each step uses constant-time hash lookups, keeping the overall complexity linear.

Description Hints 4 Solution Video 8:28

3843. First Element with Unique Frequency

Medium69.9% acceptance

You are given an integer array nums.

Return an integer denoting the first element (scanning from left to right) in nums whose frequency is unique. That is, no other integer appears the same number of times in nums. If there is no such element, return -1.

Example 1:

Input: nums = [20,10,30,30]

Output: 30

Explanation:

20 appears once.
10 appears once.
30 appears twice.
The frequency of 30 is unique because no other integer appears exactly twice.

Example 2:

Input: nums = [20,20,10,30,30,30]

Output: 20

Explanation:

20 appears twice.
10 appears once.
30 appears 3 times.
The frequency of 20, 10, and 30 are unique. The first element that has unique frequency is 20.

Example 3:

Input: nums = [10,10,20,20]

Output: -1

Explanation:

10 appears twice.
20 appears twice.
No element has a unique frequency.

Constraints:

1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁵

Topics

Hints open one at a time

Hint 1

Use two hash maps: one freq and one freqCount

Hint 2

First pass: for each x in nums do freq[x] += 1

Hint 3

Build counts of frequencies: for each f in values of freq do freqCount[f] += 1

Hint 4

Scan nums from left to right and return the first x with freqCount[freq[x]] == 1; return -1 if none

8:28

Still stuck?Read the written solution, or watch a walkthrough.

Open solution

LanguageLoading editor…

1class Solution:
2    def firstUniqueFreq(self, nums: List[int]) -> int:
3        

Starter codePython 3Spaces: 4

Examples

Case 1Case 2Case 3

Input

[20,10,30,30]

Input

[20,20,10,30,30,30]

Input

[10,10,20,20]

Your code is saved on this device.Solution