Unique Elements Counter - Problem

Given an array of integers, identify all unique elements (elements that appear exactly once) and count the duplicate elements (elements that appear more than once).

Use a set data structure to efficiently track which elements you have seen before.

Return: An array containing two integers: [number_of_unique_elements, number_of_duplicate_elements]

Input & Output

Example 1 — Mixed Elements

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

› Output: [1,2]

💡 Note: Element 1 appears once (unique), elements 2 and 3 appear multiple times (duplicates). So we have 1 unique element and 2 types of duplicate elements.

Example 2 — All Unique

$ Input: nums = [1,2,3,4,5]

› Output: [5,0]

💡 Note: All elements appear exactly once, so we have 5 unique elements and 0 duplicate types.

Example 3 — All Same

$ Input: nums = [7,7,7,7]

› Output: [0,1]

💡 Note: Element 7 appears 4 times (duplicate), so we have 0 unique elements and 1 type of duplicate element.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is using sets to track element occurrences efficiently. The optimal approach uses two sets to dynamically classify elements as unique or duplicate in a single pass. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Nested Loop

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

Iterate through each element and count how many times it appears in the entire array. Classify as unique (count=1) or duplicate (count>1).

Frequency Map Approach

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

Use a hash map to count frequency of each element in one pass, then iterate through the map to classify elements as unique or duplicate.

Single Pass Set Tracking

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

Use two sets - one for elements seen once and another for elements seen multiple times. Update counts as we encounter each element.

Brute Force Nested Loop — Algorithm Steps

Iterate through each element in the array
For each element, scan the entire array to count occurrences
If count is 1, increment unique counter; if count > 1, increment duplicate counter
Return both counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Element

Select next unprocessed element

Count Occurrences

Scan entire array counting this element

Classify

Count=1 is unique, count>1 is duplicate

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int uniqueCount = 0;
    int duplicateCount = 0;
    int* processed = (int*)calloc(20001, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i] + 10000;
        if (processed[num]) continue;
        processed[num] = 1;
        
        int count = 0;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == nums[i]) count++;
        }
        
        if (count == 1) {
            uniqueCount++;
        } else {
            duplicateCount++;
        }
    }
    
    free(processed);
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = uniqueCount;
    result[1] = duplicateCount;
    *returnSize = 2;
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: for each of n elements, scan all n elements

✓ Linear Growth

Space Complexity

O(1)

Only using counter variables, no extra data structures

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

842 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

Unique Elements Counter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Nested Loop — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler