Unique Number of Occurrences

Unique Number of Occurrences - Problem

Given an array of integers arr, return true if the number of occurrences of each value in the array is unique or false otherwise.

In other words: No two different values should have the same frequency count.

Input & Output

Example 1 — All Unique Frequencies

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

› Output: true

💡 Note: Element 1 appears 3 times, element 2 appears 2 times, element 3 appears 1 time. Frequencies [3,2,1] are all unique.

Example 2 — Duplicate Frequencies

$ Input: arr = [1,2]

› Output: false

💡 Note: Element 1 appears 1 time, element 2 appears 1 time. Both have frequency 1, so frequencies [1,1] are not unique.

Example 3 — Single Element

$ Input: arr = [5]

› Output: true

💡 Note: Only one element with frequency 1. Since there's only one frequency count, it's trivially unique.

Constraints

1 ≤ arr.length ≤ 1000
-1000 ≤ arr[i] ≤ 1000

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12

The key insight is to count frequency of each element using a hash map, then check if all frequency counts are unique using a set. Best approach is the hash map with set method. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Count and Compare All Pairs

⏱️ Time: O(n³) Space: O(1)

First count how many times each number appears using nested loops. Then compare every pair of frequency counts to see if any two are the same.

Frequency Count with Hash Map

⏱️ Time: O(n) Space: O(n)

First pass through array to count frequency of each element using a hash map. Second pass to collect all frequency counts and check if they are all unique using a set.

Single Pass Optimization

⏱️ Time: O(n) Space: O(n)

Build frequency map first, then iterate through the frequency values while checking for duplicates using a set. This avoids creating intermediate arrays.

Brute Force - Count and Compare All Pairs — Algorithm Steps

Count frequency of each unique element using nested loops
Compare all pairs of frequency counts
Return false if any two counts are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Use nested loops to count each unique element

Compare Pairs

Check all pairs of frequency counts

Result

Return false if any duplicate counts found

Code -

solution.c — C

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

bool solution(int* arr, int n) {
    int frequencies[1000];
    int freqCount = 0;
    
    // Count frequency of each unique element
    bool* visited = (bool*)calloc(n, sizeof(bool));
    for (int i = 0; i < n; i++) {
        if (visited[i]) continue;
        int count = 1;
        visited[i] = true;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] == arr[i]) {
                count++;
                visited[j] = true;
            }
        }
        frequencies[freqCount++] = count;
    }
    
    // Check if all frequencies are unique
    for (int i = 0; i < freqCount; i++) {
        for (int j = i + 1; j < freqCount; j++) {
            if (frequencies[i] == frequencies[j]) {
                free(visited);
                return false;
            }
        }
    }
    
    free(visited);
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    bool result = solution(arr, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to count frequencies + O(k²) to compare counts where k can be n

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

⚡ Linearithmic Space

178.0K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Count and Compare All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler