Find Original Array From Doubled Array - Practice Coding Problems

Find Original Array From Doubled Array - Problem

Imagine you have an array of numbers, and someone creates a mysterious new array by doubling every element and then shuffling everything together. Your mission is to be a digital detective and reverse this process!

Given an array called changed, determine if it's actually a "doubled array" - meaning it was created by taking some original array, doubling each element, combining them, and shuffling. If it is, return the original array. If it's impossible, return an empty array.

Example: If the original array was [1, 3, 4], the doubled array would contain [1, 3, 4, 2, 6, 8] in some order (each original number plus its double).

The elements in your answer can be in any order - you just need to find what the original array could have been!

Input & Output

example_1.py — Simple Case

$ Input: changed = [1,3,4,2,6,8]

› Output: [1,3,4]

💡 Note: The original array could be [1,3,4]. Doubling gives [1,3,4,2,6,8]. After shuffling, we get the input array. Each original element (1,3,4) pairs perfectly with its double (2,6,8).

example_2.py — Impossible Case

$ Input: changed = [6,3,0,1]

› Output: []

💡 Note: This cannot be a doubled array. We have 6 but no 12, we have 3 but no 6 available (since 6 would need to pair with 12), we have 1 but no 2. No valid pairing exists.

example_3.py — Empty Array

$ Input: changed = []

› Output: []

💡 Note: Empty array is valid - the original array was also empty. Zero elements can be perfectly paired (vacuously true).

Constraints

1 ≤ changed.length ≤ 10⁵
0 ≤ changed[i] ≤ 10⁵
The array length must be even for a valid doubled array

Visualization

Tap to expand

Understanding the Visualization

Dump the Laundry

You have a basket of mixed socks in random order

Sort by Size

Arrange socks from smallest to largest for systematic pairing

Pair Small with Large

Match each small sock with its double-sized partner

Check Completeness

If every sock finds its pair, you've solved the puzzle!

Key Takeaway

🎯 Key Insight: Just like sorting socks makes pairing easier, sorting the array first ensures we process smaller elements before larger ones, preventing conflicts and achieving optimal O(n log n) performance!

Asked in

G Google 45

The optimal approach uses sorting + frequency counting with O(n log n) time complexity. Key insight: process smaller elements first to avoid double-counting. Sort the array, then iterate through elements, pairing each with its double using a frequency map.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	For each element, search for its double in the remaining array
Two-Pass Hash Table	O(n log n)	O(n)	Count all elements first, then systematically find pairs
Sorting + One-Pass (Optimal)	O(n log n)	O(n)	Sort array first, then process elements in order with frequency map
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort array and use two pointers to find pairs efficiently

Brute Force (Nested Loops) — Algorithm Steps

Return empty array if length is odd (impossible to have pairs)
For each unused element x, search for unused element 2x
If found, mark both as used and add x to result
If any element can't find its pair, return empty array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Element

Pick an unused element as potential original

Search for Double

Linear search through array for its double

Mark as Used

Mark both elements as used if pair found

Code -

solution.c — C

int* findOriginalArray(int* changed, int changedSize, int* returnSize) {
    *returnSize = 0;
    if (changedSize % 2 == 1) return NULL;
    
    bool* used = (bool*)calloc(changedSize, sizeof(bool));
    int* result = (int*)malloc((changedSize / 2) * sizeof(int));
    int resultIdx = 0;
    
    for (int i = 0; i < changedSize; i++) {
        if (used[i]) continue;
        
        bool found = false;
        for (int j = 0; j < changedSize; j++) {
            if (i != j && !used[j] && changed[j] == 2 * changed[i]) {
                used[i] = true;
                used[j] = true;
                result[resultIdx++] = changed[i];
                found = true;
                break;
            }
        }
        
        if (!found) {
            free(used);
            free(result);
            return NULL;
        }
    }
    
    *returnSize = resultIdx;
    free(used);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we search through up to n elements to find its double

⚠ Quadratic Growth

Space Complexity

O(n)

Need array to track which elements are used

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler