Sum of Unique Elements - Practice Coding Problems

Sum of Unique Elements - Problem

Imagine you're a data analyst working with survey responses, and you need to identify and sum up all the unique responses - those that appeared exactly once in your dataset.

Given an integer array nums, your task is to find all elements that appear exactly once in the array and return their sum.

What makes an element unique? An element is considered unique if it appears exactly once in the entire array - no more, no less.

Example: In the array [1, 2, 3, 2], the elements 1 and 3 are unique (appear once), while 2 appears twice. So the sum of unique elements would be 1 + 3 = 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Elements 1 and 3 appear exactly once, while 2 appears twice. Sum of unique elements: 1 + 3 = 4

example_2.py — All Unique

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

› Output: 15

💡 Note: All elements appear exactly once, so we sum all: 1 + 2 + 3 + 4 + 5 = 15

example_3.py — No Unique Elements

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

› Output: 0

💡 Note: Every element appears exactly twice, so there are no unique elements. Sum = 0

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
Elements can be negative, zero, or positive

Visualization

Tap to expand

Understanding the Visualization

First Purchase

When a seat is bought for the first time, add it to the promotion sum

Duplicate Purchase

When the same seat is bought again, remove it from the promotion sum

Multiple Purchases

If bought more times, ignore it (already removed from promotion)

Final Count

The remaining sum represents seats bought exactly once

Key Takeaway

🎯 Key Insight: By tracking additions and subtractions in real-time, we can identify unique elements in a single pass without needing to store all frequencies first.

Asked in

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

The optimal solution uses a one-pass hash table approach that dynamically tracks the sum by adding elements when first encountered and subtracting them when they become non-unique. This achieves O(n) time and O(n) space complexity while being more efficient than the two-pass approach.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Track frequencies and sum simultaneously in a single pass
Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass sums unique elements
Brute Force (Nested Loops)	O(n²)	O(1)	For each element, count its occurrences by checking against all other elements

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize sum to 0 and create a hash table for frequencies
For each element in the array:
If element is new (frequency 0), add it to sum and mark as seen
If element seen once before, subtract it from sum (no longer unique)
If element seen multiple times, do nothing (already subtracted)
Update frequency count
Return the final sum

Visualization

Tap to expand

Step-by-Step Walkthrough

First Occurrence

Add element to sum (potentially unique)

Second Occurrence

Remove element from sum (no longer unique)

Further Occurrences

Ignore element (already handled)

Code -

solution.c — C

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

#define MAX_SIZE 1001
#define OFFSET 100

int sumOfUnique(int* nums, int numsSize) {
    int totalSum = 0;
    int freqCount[MAX_SIZE] = {0};
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        int count = freqCount[num + OFFSET];
        
        if (count == 0) {
            // First time seeing this number, add to sum
            totalSum += num;
        } else if (count == 1) {
            // Second time seeing this number, remove from sum
            totalSum -= num;
        }
        // If count > 1, do nothing (already removed)
        
        freqCount[num + OFFSET] = count + 1;
    }
    
    return totalSum;
}

int main() {
    int nums[1000];
    int n = 0;
    
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", sumOfUnique(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with O(1) hash operations

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n unique elements

⚡ Linearithmic Space

58.2K Views

High Frequency

~12 min Avg. Time

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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler