Single Element in a Sorted Array - Practice Coding Problems

Single Element in a Sorted Array - Problem

You're given a sorted array with a unique twist - every element appears exactly twice, except for one lonely element that appears only once. Your mission? Find that single element!

Here's the catch: your solution must be lightning fast with O(log n) time complexity and use only O(1) extra space. This means you can't simply iterate through the entire array - you need to be clever!

Example: In [1,1,2,3,3,4,4,8,8], the element 2 appears only once while all others appear twice.

Think about how the sorted property combined with the pairing pattern can help you eliminate half the search space at each step!

Input & Output

example_1.py — Python

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

› Output: 2

💡 Note: The element 2 appears only once while all other elements (1,3,4,8) appear exactly twice

example_2.py — Python

$ Input: [3,3,7,7,10,11,11]

› Output: 10

💡 Note: Elements 3,7,11 appear twice each, but 10 appears only once

example_3.py — Python

$ Input: [1]

› Output: 1

💡 Note: Edge case: array with single element - that element appears only once

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
nums.length is always odd
Array is sorted in non-decreasing order
Every element appears exactly twice except one element which appears once

Visualization

Tap to expand

Understanding the Visualization

Normal Pattern

In arrays with only pairs, elements at even indices (0,2,4...) match their next neighbor

Disruption Point

The single element breaks this pattern - pairs after it shift to odd indices

Binary Decision

Check if mid (even) equals mid+1 to determine which side has the disruption

Key Takeaway

🎯 Key Insight: The single element acts like a shift point - pairs before it align with even indices, pairs after it align with odd indices. Binary search leverages this pattern to achieve O(log n) time complexity.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses binary search with index parity analysis. Key insight: before the single element, pairs start at even indices (0,2,4...), but after the single element, the pairing shifts and pairs start at odd indices. By checking if nums[mid] == nums[mid+1] at even indices, we can determine which half contains the single element and eliminate the other half, achieving O(log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Linear Search	O(n)	O(1)	Check each element to see if it has a pair
Binary Search (Optimal)	O(log n)	O(1)	Use binary search by checking index parity to eliminate half the search space

Linear Search — Algorithm Steps

Iterate through array with step size 2
At each position i, check if nums[i] == nums[i+1]
If not equal, nums[i] is the single element
If we reach the end, the last element is single

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at beginning

Compare nums[0] with nums[1]

Check next pair

If equal, move to next pair at index i+2

Found mismatch

First element without matching pair is the answer

Code -

solution.c — C

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

int singleNonDuplicate(int* nums, int numsSize) {
    // Check pairs starting from index 0
    for (int i = 0; i < numsSize - 1; i += 2) {
        if (nums[i] != nums[i + 1]) {
            return nums[i];
        }
    }
    // If no mismatch found, last element is single
    return nums[numsSize - 1];
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

We potentially need to check every element in the worst case

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra variables

✓ Linear Space

42.3K Views

Medium-High Frequency

~15 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

Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler