Unique Number of Occurrences - Practice Coding Problems

Unique Number of Occurrences - Problem

You are given an array of integers arr. Your task is to determine if the frequency count of each unique value in the array is itself unique across all values.

In other words, no two different numbers should appear the same number of times in the array.

Example: If the number 3 appears twice and the number 5 also appears twice, then the answer is false because both numbers have the same frequency (2).

Return true if all frequency counts are unique, or false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: [1,2,2,1,1,3]

› Output: true

💡 Note: The value 1 appears 3 times, 2 appears 2 times, and 3 appears 1 time. All frequencies (3, 2, 1) are unique.

example_2.py — Duplicate Frequencies

$ Input: [1,2]

› Output: false

💡 Note: Both 1 and 2 appear exactly 1 time each. Since both have the same frequency (1), the frequencies are not unique.

example_3.py — All Same Elements

$ Input: [1,1,1,1]

› Output: true

💡 Note: Only one unique value (1) appears 4 times. Since there's only one frequency count, it's trivially unique.

Visualization

Tap to expand

Understanding the Visualization

Count Checkouts

Count how many times each book was checked out: Book A (3 times), Book B (2 times), Book C (1 time)

Check for Duplicates

Verify that no two books have the same checkout count

Determine Result

If all checkout counts are different, return true; otherwise false

Key Takeaway

🎯 Key Insight: We only care about frequency counts being unique, not the actual values or their positions in the array

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build frequency map plus O(k) to check uniqueness where k ≤ n

✓ Linear Growth

Space Complexity

O(n)

Hash map for frequencies plus set for uniqueness check

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
All elements are integers
Array can contain negative numbers and duplicates

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal approach uses a hash table to count element frequencies in O(n) time, then checks if all frequency counts are unique using a set. This gives us the best possible time complexity while maintaining clean, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	Count frequency of each element manually, then check for duplicate counts
One-Pass Hash + Set (Optimal)	O(n)	O(n)	Build frequency map and check for duplicate frequencies in a single efficient approach
Two-Pass Hash Table	O(n)	O(n)	Build frequency map first, then check for duplicate counts

Brute Force (Nested Loops) — Algorithm Steps

Find all unique elements in the array
For each unique element, count its occurrences by scanning the entire array
Store all frequency counts
Check if any frequency count appears more than once

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Unique Elements

Find all unique values: [1, 2, 3]

Count Element 1

Scan entire array counting 1's: appears 3 times

Count Element 2

Scan entire array counting 2's: appears 2 times

Count Element 3

Scan entire array counting 3's: appears 1 time

Check Uniqueness

Frequencies [3,2,1] are all unique → return true

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool uniqueOccurrences(int* arr, int arrSize) {
    int frequencies[2001] = {0}; // Assuming range [-1000, 1000]
    int uniqueCount = 0;
    
    // Count frequencies
    for (int i = 0; i < arrSize; i++) {
        int index = arr[i] + 1000; // Offset for negative numbers
        if (frequencies[index] == 0) {
            uniqueCount++;
        }
        frequencies[index]++;
    }
    
    // Collect non-zero frequencies
    int* freqList = (int*)malloc(uniqueCount * sizeof(int));
    int idx = 0;
    for (int i = 0; i < 2001; i++) {
        if (frequencies[i] > 0) {
            freqList[idx++] = frequencies[i];
        }
    }
    
    // Check for duplicates in frequency list
    for (int i = 0; i < uniqueCount - 1; i++) {
        for (int j = i + 1; j < uniqueCount; j++) {
            if (freqList[i] == freqList[j]) {
                free(freqList);
                return false;
            }
        }
    }
    
    free(freqList);
    return true;
}

int main() {
    int arr[1000];
    int size = 0;
    char c;
    int num = 0;
    bool inNumber = false;
    bool negative = false;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = true;
        } else if (c == '-') {
            negative = true;
            inNumber = true;
        } else if (c == ',' || c == ']') {
            if (inNumber) {
                if (negative) num = -num;
                arr[size++] = num;
                num = 0;
                inNumber = false;
                negative = false;
            }
        }
    }
    
    printf("%s\n", uniqueOccurrences(arr, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we scan the entire array to count occurrences

⚠ Quadratic Growth

Space Complexity

O(n)

We store frequency counts for all unique elements

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000
All elements are integers
Array can contain negative numbers and duplicates

89.5K Views

Medium Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler