Sum of Unique Elements - Practice Coding Problems

Sum of Unique Elements - Problem

You are given an integer array nums. The unique elements of an array are the elements that appear exactly once in the array.

Return the sum of all the unique elements of nums.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Elements 1 and 3 appear exactly once, so sum = 1 + 3 = 4. Element 2 appears twice so it's not unique.

Example 2 — All Unique

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

› Output: 15

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

Example 3 — No Unique Elements

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

› Output: 0

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

Constraints

1 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array with some duplicate elements

Find Unique

Identify elements appearing exactly once

Sum Result

Add up all unique elements

Key Takeaway

🎯 Key Insight: Only elements appearing exactly once contribute to the final sum

Asked in

a Amazon 35 G Google 28

The key insight is to identify elements that appear exactly once and sum them up. The best approach uses a hash map to count frequencies in O(n) time, or the clever one-pass method that adds on first occurrence and subtracts on duplicates. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimized	O(n)	O(n)	Track sum and duplicates in a single pass using hash map
Brute Force	O(n²)	O(1)	Check each element against all others to determine if it's unique
Frequency Count (Hash Map)	O(n)	O(n)	Use a hash map to count frequencies, then sum elements with count = 1

One-Pass Optimized — Algorithm Steps

Initialize sum and a set to track seen elements
For each element, check if seen before
If first time: add to sum and mark as seen
If seen before: subtract from sum (making its net contribution 0)

Visualization

Tap to expand

Step-by-Step Walkthrough

First Occurrence

Add element to sum and mark as seen

Second Occurrence

Subtract element from sum (net = 0)

Final Sum

Only unique elements remain in sum

Code -

solution.c — C

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

#define MAX_SIZE 1000

int solution(int* nums, int numsSize) {
    int seen[MAX_SIZE];
    int seenSize = 0;
    int totalSum = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        
        // Check if we've seen this number before
        for (int j = 0; j < seenSize; j++) {
            if (seen[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        
        if (found) {
            // Seen before, subtract it
            totalSum -= nums[i];
        } else {
            // First time seeing, add to sum
            totalSum += nums[i];
            seen[seenSize++] = nums[i];
        }
    }
    
    return totalSum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array
    int nums[1000];
    int size = 0;
    char* ptr = line + 1; // Skip opening bracket
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ' ') {
            ptr++;
            continue;
        }
        nums[size++] = atoi(ptr);
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array of size n, hash map operations are O(1)

✓ Linear Growth

Space Complexity

O(n)

Hash set stores up to n unique elements in worst case

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~10 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 Optimized — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler