Once Twice

Once Twice - Problem

You are given an integer array nums with the following properties:

Exactly one element appears once
Exactly one element appears twice
All other elements appear exactly three times

Return an integer array of length 2, where:

The first element is the one that appears once
The second element is the one that appears twice

Your solution must run in O(n) time and O(1) space.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2]

💡 Note: Element 1 appears once, element 2 appears twice, element 3 appears three times. Return [1,2].

Example 2 — Different Numbers

$ Input: nums = [4,4,4,5,6,5]

› Output: [6,5]

💡 Note: Element 6 appears once, element 5 appears twice, element 4 appears three times. Return [6,5].

Example 3 — Minimum Length

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

› Output: [1,2]

💡 Note: Element 0 appears three times, element 1 appears once, element 2 appears twice. Return [1,2].

Constraints

3 ≤ nums.length ≤ 3 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Each integer appears either 1, 2, or 3 times
Exactly one integer appears once
Exactly one integer appears twice

Visualization

Tap to expand

Asked in

f Facebook 25 G Google 20 a Amazon 15 M Microsoft 12

The key insight is recognizing that elements appearing three times will cancel out in XOR operations, leaving only the elements appearing once and twice. The optimal approach uses bit manipulation to achieve O(n) time and O(1) space complexity by leveraging XOR properties to mathematically isolate the target elements.

Common Approaches

✓ Bit Manipulation (Optimal)

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

Elements appearing 3 times cancel out in XOR. Use mathematical properties to separate the element appearing once from the element appearing twice in O(1) space.

Brute Force

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

For each unique element in the array, count how many times it appears by scanning the entire array. Store elements with frequency 1 and 2.

Frequency Count with Hash Map

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

Make two passes through the array: first pass builds a frequency map, second pass identifies the elements that appear once and twice.

Bit Manipulation (Optimal) — Algorithm Steps

XOR all elements to get combined result of once and twice elements
Find a distinguishing bit between the two target elements
Separate elements into two groups and XOR each group

Visualization

Tap to expand

Step-by-Step Walkthrough

XOR All Elements

Elements appearing 3 times cancel out

Find Differentiating Bit

Isolate bit where targets differ

Group and Separate

Split elements and XOR each group

Code -

solution.c — C

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

int cmp(const void* a, const void* b) {
    int x = *(int*)a, y = *(int*)b;
    return (x > y) - (x < y);
}

void solution(int* nums, int numsSize, int* result) {
    qsort(nums, numsSize, sizeof(int), cmp);
    result[0] = 0;
    result[1] = 0;
    int pairs[2], pairCount = 0, single = 0, singleFound = 0;
    int i = 0;
    while (i < numsSize) {
        if (i + 1 >= numsSize || nums[i] != nums[i+1]) {
            single = nums[i];
            singleFound = 1;
            i++;
        } else if (i + 2 >= numsSize || nums[i] != nums[i+2]) {
            if (pairCount < 2) pairs[pairCount] = nums[i];
            pairCount++;
            i += 2;
        } else {
            i += 3;
        }
    }
    if (singleFound && pairCount == 1) {
        result[0] = single;
        result[1] = pairs[0];
    } else if (!singleFound && pairCount == 2) {
        result[0] = pairs[0];
        result[1] = pairs[1];
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    static int nums[30000];
    int size = 0;
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        char* endp;
        nums[size++] = (int)strtol(p, &endp, 10);
        p = endp;
    }
    int result[2];
    solution(nums, size, result);
    printf("[%d,%d]\n", result[0], result[1]);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three passes through the array for XOR operations

✓ Linear Growth

Space Complexity

O(1)

Only using a few integer variables for bit operations

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler