Single Number

Single Number - Problem

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

You must implement a solution with a linear runtime complexity and use only constant extra space.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Numbers 2 and 1 each appear twice, while 3 appears only once. The single number is 3.

Example 2 — Single Element

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

› Output: 4

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

Example 3 — Minimum Size

$ Input: nums = [1]

› Output: 1

💡 Note: Array has only one element, so 1 is the single number that doesn't appear twice.

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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 31 A Apple 28 f Facebook 25

The key insight is using XOR bit manipulation where identical numbers cancel out (a ⊕ a = 0). Best approach is XOR all elements - pairs disappear leaving only the single number. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Count Each Element

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

Check every element against all other elements to count how many times it appears. The element that appears only once is our answer.

Hash Map - Frequency Count

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

Use a hash map to count how many times each number appears. Then find the number with frequency 1. This meets the linear time requirement but uses extra space.

XOR Bit Manipulation (Optimal)

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

XOR all numbers together. Since XOR of two identical numbers is 0, and XOR of any number with 0 is the number itself, all pairs will cancel out leaving only the single number. This is the optimal solution meeting both time and space requirements.

Brute Force - Count Each Element — Algorithm Steps

For each element in array
Count its occurrences by scanning entire array
Return the element with count = 1

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Element

Select first element (2) and count occurrences

Count Matches

Scan entire array counting how many times 2 appears

Check Next

If count ≠ 1, move to next element and repeat

Code -

solution.c — C

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

int singleNumber(int* nums, int numsSize) {
    for (int i = 0; i < numsSize; i++) {
        int count = 0;
        
        for (int j = 0; j < numsSize; j++) {
            if (nums[i] == nums[j]) {
                count++;
            }
        }
        
        if (count == 1) {
            return nums[i];
        }
    }
    
    return -1;
}

int main() {
    char line[1000000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    int* nums = (int*)malloc(30000 * sizeof(int));
    int numsSize = 0;
    
    char* ptr = line;
    
    while (*ptr) {
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            int num = atoi(ptr);
            nums[numsSize++] = num;
            
            if (*ptr == '-') ptr++;
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    int result = singleNumber(nums, numsSize);
    
    printf("%d\n", result);
    
    free(nums);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan all n elements to count occurrences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no extra data structures

✓ Linear Space

336.8K Views

High Frequency

~15 min Avg. Time

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

Brute Force - Count Each Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler