Once Twice - Practice Coding Problems

Once Twice - Problem

You're given an integer array with a unique frequency pattern: exactly one element appears once, exactly one element appears twice, and all other elements appear exactly three times.

Your mission is to identify the two special elements and return them as an array: [once_element, twice_element].

Challenge: Solve this in O(n) time and O(1) space!

Example: In array [3, 3, 2, 3, 1, 1], element 2 appears once and element 1 appears twice, so return [2, 1].

Input & Output

example_1.py — Basic Case

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

› Output: [2, 1]

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

example_2.py — Different Order

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

› Output: [2, 1]

💡 Note: Element 2 appears once, element 1 appears twice, element 3 appears three times. Order in array doesn't matter.

example_3.py — Negative Numbers

$ Input: [-1, -1, 0, 2, 2, 2]

› Output: [0, -1]

💡 Note: Element 0 appears once, element -1 appears twice, element 2 appears three times. Works with negative numbers too.

Constraints

3 ≤ nums.length ≤ 3 × 10⁴
-3 × 10⁴ ≤ nums[i] ≤ 3 × 10⁴
Exactly one element appears once
Exactly one element appears twice
All other elements appear exactly three times
Solution must run in O(n) time and O(1) space

Visualization

Tap to expand

Understanding the Visualization

Crime Scene Analysis

You have an array where most elements appear 3 times (normal citizens), but two are special

Frequency Investigation

Count how many times each number appears using your detective tools (hash map or bit manipulation)

Identify Suspects

The element appearing once is suspect A, the element appearing twice is suspect B

Case Closed

Return both suspects as [suspect_A, suspect_B]

Key Takeaway

🎯 Key Insight: Like a skilled detective, you can identify the special elements by their unique frequency signatures - one appears once, one appears twice, while all others appear three times.

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses bit manipulation with XOR operations to achieve O(n) time and O(1) space. While hash table approaches are intuitive and work in O(n) time, they require O(n) extra space. The key insight is that XOR can help separate numbers based on their frequency patterns, making it possible to identify the once and twice appearing elements without extra storage.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table	O(n)	O(n)	Build frequency map in single pass, then find elements with count 1 and 2
Brute Force (Nested Loops)	O(n²)	O(1)	Count frequency of each element by scanning the entire array multiple times

One-Pass Hash Table — Algorithm Steps

Initialize an empty hash map for frequency counting
Iterate through array once, updating frequency count for each element
Iterate through the frequency map
Find element with frequency 1 (appears once)
Find element with frequency 2 (appears twice)
Return both elements as [once, twice]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Map

Create empty hash map for frequency counting

Count Frequencies

Single pass through array, updating count for each element

Find Special Elements

Scan frequency map to find elements with count 1 and 2

Return Result

Return [once_element, twice_element]

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int key;
    int value;
} HashItem;

int* solution(int* nums, int numsSize, int* returnSize) {
    HashItem freq[MAX_SIZE] = {0};
    int freqSize = 0;
    
    // Count frequencies
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < freqSize; j++) {
            if (freq[j].key == nums[i]) {
                freq[j].value++;
                found = 1;
                break;
            }
        }
        if (!found) {
            freq[freqSize].key = nums[i];
            freq[freqSize].value = 1;
            freqSize++;
        }
    }
    
    // Find elements with frequency 1 and 2
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < freqSize; i++) {
        if (freq[i].value == 1) {
            result[0] = freq[i].key;
        } else if (freq[i].value == 2) {
            result[1] = freq[i].key;
        }
    }
    
    *returnSize = 2;
    return result;
}

int main() {
    int nums[MAX_SIZE];
    int size = 0;
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[],\n");
    while (token != NULL && size < MAX_SIZE) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to build frequency map + one pass through unique elements

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique elements

⚡ Linearithmic Space

52.3K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler