Codestin Search App

Single Number - Problem

Imagine you have a collection of items where every item appears exactly twice, except for one special item that appears only once. Your mission is to find that single unique item efficiently!

Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.

Challenge: You must implement a solution with linear runtime complexity O(n) and use only constant extra space O(1).

Example: In the array [2, 2, 1], the number 1 appears only once while 2 appears twice. So the answer is 1.

Input & Output

example_1.py — Basic Case

$ Input: [2, 2, 1]

› Output: 1

💡 Note: The number 1 appears once while 2 appears twice, so the single number is 1.

example_2.py — Larger Array

$ Input: [4, 1, 2, 1, 2]

› Output: 4

💡 Note: Numbers 1 and 2 each appear twice, while 4 appears only once, making 4 the single number.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: The array contains only one element, so that element is the single number.

Visualization

Tap to expand

Understanding the Visualization

Start the Magic Show

Begin with an empty stage (result = 0)

First Twin Appears

The first occurrence of each number steps onto the stage

Twin Reunion

When the second occurrence meets its twin, both vanish with XOR magic!

The Lone Survivor

Only the single number remains on stage - our answer!

Key Takeaway

🎯 Key Insight: XOR is the perfect tool for this problem because it naturally cancels out pairs (a⊕a=0) while preserving single elements (a⊕0=a), giving us an elegant O(n) time, O(1) space solution!

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n/2 + 1 elements in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-3 × 10⁴ ≤ nums[i] ≤ 3 × 10⁴
Each element in the array appears twice except for one element which appears only once

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses XOR bit manipulation to achieve O(n) time and O(1) space complexity. The key insight is that a ⊕ a = 0 and a ⊕ 0 = a, so XORing all numbers together cancels out the pairs, leaving only the single number.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Toggle (One Pass)	O(n)	O(n)	Use a hash set to track seen numbers, toggling them in and out
Brute Force (Nested Loops)	O(n²)	O(1)	For each element, count its occurrences in the entire array
XOR Bit Manipulation (Optimal)	O(n)	O(1)	Use XOR properties: a⊕a=0 and a⊕0=a to cancel out pairs

Hash Set Toggle (One Pass) — Algorithm Steps

Initialize an empty hash set
Iterate through the array once
For each number: if it's in the set, remove it; otherwise, add it
Return the single remaining number in the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 2

Add 2 to the set (first occurrence)

Process 2

Remove 2 from the set (second occurrence)

Process 1

Add 1 to the set (first occurrence) - this remains

Code -

solution.c — C

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

int singleNumber(int* nums, int numsSize) {
    // Simple approach for C - sort and find single
    // Sort the array first
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = 0; j < numsSize - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
    
    // Find the single number
    for (int i = 0; i < numsSize; i += 2) {
        if (i == numsSize - 1 || nums[i] != nums[i + 1]) {
            return nums[i];
        }
    }
    return -1;
}

int main() {
    int nums[1000];
    int size = 0;
    char ch;
    int num = 0;
    int sign = 1;
    
    while ((ch = getchar()) != '\n' && ch != EOF) {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
        } else if (ch == '-') {
            sign = -1;
        } else if (ch == ',' || ch == ']') {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
        }
    }
    
    printf("%d\n", singleNumber(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n/2 + 1 elements in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-3 × 10⁴ ≤ nums[i] ≤ 3 × 10⁴
Each element in the array appears twice except for one element which appears only once

73.9K Views

High Frequency

~12 min Avg. Time

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

Hash Set Toggle (One Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler