Single Number III - Practice Coding Problems

Single Number III - Problem

Imagine you have an array of integers where exactly two elements appear only once and all other elements appear exactly twice. Your mission is to find these two unique elements!

This problem is a fascinating extension of bit manipulation techniques. While finding one unique number among duplicates is straightforward using XOR, finding two unique numbers requires a clever twist.

The Challenge: You must solve this in O(n) time complexity and O(1) space complexity - no hash tables allowed!

Example: Given [1,2,1,3,2,5], the two unique numbers are 3 and 5.

Input & Output

example_1.py — Basic Case

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

› Output: [3,5]

💡 Note: Numbers 1 and 2 appear twice each, while 3 and 5 appear only once. The algorithm uses XOR to find that 3⊕5=6, then uses bit 2 (010) to separate them into different groups.

example_2.py — Negative Numbers

$ Input: nums = [-1,0]

› Output: [-1,0]

💡 Note: Both -1 and 0 appear only once. The XOR of all elements is -1⊕0=-1, and the distinguishing bit separates them correctly.

example_3.py — Larger Numbers

$ Input: nums = [0,1,0,3,0,4,0,4,3]

› Output: [1,3]

💡 Note: Wait, this violates the constraint! Let's use: nums = [0,1]. Here 0 and 1 both appear once, so XOR gives 0⊕1=1, and bit 1 separates them.

Visualization

Tap to expand

Understanding the Visualization

Combine All Fingerprints

XOR all numbers - duplicates cancel out, leaving only the XOR of our two targets

Find the Key Difference

The rightmost set bit in our XOR result shows us how the two numbers differ

Divide and Conquer

Split the array based on this distinguishing bit - each unique number goes to a different group

Extract the Individuals

XOR each group separately to eliminate pairs and reveal the unique number in each group

Key Takeaway

🎯 Key Insight: XOR eliminates duplicate pairs and reveals the combined signature of unique numbers. The rightmost set bit in this signature is our 'fingerprint scanner' that perfectly separates the two unique suspects!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to XOR all elements, then another pass to separate groups

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for XOR operations and bit manipulation

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 3 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Each integer appears exactly twice except for two integers
The two unique integers are guaranteed to be different

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 24 Apple 19

The optimal solution uses bit manipulation with XOR properties. First, XOR all elements to get the combined result of both unique numbers. Then find the rightmost set bit to distinguish between them, partition the array into two groups based on this bit, and XOR each group separately to find the two unique numbers. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Bit Manipulation (O(1) Space)	O(n)	O(1)	Use XOR properties to separate two unique numbers using distinguishing bit
Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass finds elements with count 1
Brute Force (Nested Loops)	O(n²)	O(1)	Check each number's frequency by comparing with all other numbers

Optimal Bit Manipulation (O(1) Space) — Algorithm Steps

XOR all numbers to get xor_result = a ⊕ b (where a,b are the two unique numbers)
Find rightmost set bit in xor_result using (xor_result & -xor_result)
This bit distinguishes the two unique numbers
Partition array into two groups based on this bit
XOR elements in each group separately to find the unique numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

XOR All Elements

Get combined signature of both unique numbers

Find Distinguishing Bit

Rightmost set bit that differs between the two unique numbers

Partition Into Groups

Separate elements based on distinguishing bit

XOR Each Group

Find unique element in each group

Code -

solution.c — C

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

int* singleNumber(int* nums, int numsSize, int* returnSize) {
    // Step 1: XOR all numbers to get xor_result = a ^ b
    int xor_result = 0;
    for (int i = 0; i < numsSize; i++) {
        xor_result ^= nums[i];
    }
    
    // Step 2: Find rightmost set bit (distinguishing bit)
    int diff_bit = xor_result & (-xor_result);
    
    // Step 3: Separate numbers into two groups and find unique number in each
    int a = 0, b = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] & diff_bit) {
            a ^= nums[i];  // Group 1: numbers with diff_bit set
        } else {
            b ^= nums[i];  // Group 2: numbers without diff_bit set
        }
    }
    
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = a;
    result[1] = b;
    *returnSize = 2;
    return result;
}

int main() {
    int nums[] = {1, 2, 1, 3, 2, 5};
    int numsSize = 6;
    int returnSize;
    int* result = singleNumber(nums, numsSize, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to XOR all elements, then another pass to separate groups

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for XOR operations and bit manipulation

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 3 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Each integer appears exactly twice except for two integers
The two unique integers are guaranteed to be different

84.5K Views

Medium-High Frequency

~18 min Avg. Time

3.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

Optimal Bit Manipulation (O(1) Space) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler