Single Number LeetCode Solution (Easy) (2026)

Approach Summary

XOR all numbers. Pairs cancel out (x ^ x = 0). The result is the single number.

Practice Mode

Solve it yourself before revealing the code

DSA interviews test reasoning from brute force to optimal. Think through the constraints first.

Full Solution & Approach

XOR has three properties that make this a one-liner: a ^ a = 0, a ^ 0 = a, and XOR is commutative and associative. Since every number except one appears exactly twice, XORing the entire array cancels every duplicate pair to 0 and leaves only the singleton. Order does not matter because XOR is commutative, so a single pass with result = 0 and result ^= n for each n works regardless of arrangement. This is the canonical linear-time, constant-space solution, and the trick is worth remembering — the same XOR idea generalizes to finding the missing number and the two odd-occurring numbers. Any non-bitwise approach (hash map, sort, or sum) either uses O(n) extra space or O(n log n) time.

One pass with a constant-time XOR per element — O(n) time. A single integer variable — O(1) space.

Solution Code

Solution

public int singleNumber(int[] nums) {
    int result = 0;
    for (int n : nums) result ^= n;
    return result;
}

int singleNumber(const vector<int>& nums) {
    int result = 0;
    for (int n : nums) result ^= n;
    return result;
}

def single_number(nums: list[int]) -> int:
    result = 0
    for n in nums:
        result ^= n
    return result

function singleNumber(nums) {
  return nums.reduce((acc, n) => acc ^ n, 0);
}

Edge Cases to Watch

Single element — the singleton itself
Negative numbers — XOR works identically on two's-complement integers
Large arrays — no overflow risk with XOR, unlike sum-based tricks

Algorithmic Pattern

Master the Bit Manipulation Pattern

View Pattern Guide →

Study the core invariant, step-by-step decision framework, and common interview traps for the Bit Manipulation pattern.

Framework: Bit Manipulation • Interview Prep: Tested at FAANG • Explore all Bit Manipulation problems & invariants →

How to Recognize This Pattern

Find element appearing once, all others twice
XOR trick

Complexity Analysis

Time Complexity

O(n)

Space Complexity

O(1)

Frequently Asked Questions

What is the optimal time and space complexity for Single Number?

The optimal solution for Single Number achieves O(n) runtime complexity and requires O(1) auxiliary space. One pass with a constant-time XOR per element — O(n) time. A single integer variable — O(1) space.

How do I identify that Single Number requires the Bit Manipulation pattern?

In technical interviews, look for key problem signals: Find element appearing once, all others twice; XOR trick. Recognizing these invariants allows you to bypass naive brute-force exhaustive search in favor of Bit Manipulation strategy.

What critical edge cases must be handled in Single Number?

Essential edge cases to verify include: Single element — the singleton itself; Negative numbers — XOR works identically on two's-complement integers; Large arrays — no overflow risk with XOR, unlike sum-based tricks. Always walk through these scenarios with your interviewer before coding.

Which tech companies frequently ask Single Number?

Single Number is a Easy-difficulty question tagged with high recurrence. It is actively asked in technical screening and onsite interview loops at Amazon, Apple, Bloomberg.

Single Number LeetCode Solution