Recover the Original Array - Practice Coding Problems

Recover the Original Array - Problem

Imagine Alice had an array of n positive integers. She performed a clever transformation: she picked a positive integer k and created two new arrays by subtracting k from each element (creating the lower array) and adding k to each element (creating the higher array).

Here's the twist: Alice accidentally mixed all the numbers from both arrays together and lost track of the original array! 🤔

Your mission: Given an array nums containing 2n integers (where exactly n came from the lower array and n came from the higher array), reconstruct Alice's original array.

Example: If the original array was [5, 10, 15] with k=2, Alice would create:

Lower: [3, 8, 13] (subtract 2 from each)
Higher: [7, 12, 17] (add 2 to each)
Mixed: [3, 7, 8, 12, 13, 17] (shuffled together)

From the mixed array, you need to find the original [5, 10, 15]!

Input & Output

example_1.py — Basic case with k=1

$ Input: [2,10,6,4,8,12]

› Output: [3,7,11]

💡 Note: The original array [3,7,11] with k=1 creates lower=[2,6,10] and higher=[4,8,12]. When mixed: [2,10,6,4,8,12]

example_2.py — Larger k value

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

› Output: [2,2]

💡 Note: The original array [2,2] with k=1 creates lower=[1,1] and higher=[3,3]. Mixed together: [1,1,3,3]

example_3.py — Single element case

$ Input: [5,11]

› Output: [8]

💡 Note: The original array [8] with k=3 creates lower=[5] and higher=[11]. Mixed: [5,11]

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) possible k values, each requiring O(n) verification time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for frequency map and result array

⚡ Linearithmic Space

Constraints

Asked in

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible k Values)	O(n³)	O(n)	Try every possible k value and check if we can form valid pairs
Two Pointers (Sorted Array)	O(n² log n)	O(n)	Sort array and systematically match pairs using the smallest element strategy
Two-Pass Hash Table (Frequency-Based)	O(n² log n)	O(n)	Build frequency map first, then systematically try k values and match pairs

Brute Force (Try All Possible k Values) — Algorithm Steps

Generate all possible k values from pairs in the array
For each k, try to match every number x with x+2k
Use a frequency map to track available numbers
If we can form exactly n pairs, reconstruct the original array
Return the first valid reconstruction found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate K Candidates

Try every pair difference divided by 2 as potential k

Test Each K

For each k, attempt to pair all numbers with their +2k counterparts

Validate Pairing

Check if exactly n pairs can be formed using available numbers

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int* recoverArray(int* nums, int numsSize, int* returnSize) {
    int n = numsSize / 2;
    *returnSize = n;
    
    // Try all possible k values
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if ((nums[j] - nums[i]) % 2 != 0) continue;
            
            int k = (nums[j] - nums[i]) / 2;
            if (k == 0) continue;
            
            // Create frequency array (assuming reasonable range)
            int freq[100001] = {0}; // Adjust size based on constraints
            int offset = 50000; // Handle negative numbers
            
            for (int idx = 0; idx < numsSize; idx++) {
                freq[nums[idx] + offset]++;
            }
            
            int* original = (int*)malloc(n * sizeof(int));
            int origIdx = 0;
            int valid = 1;
            
            // Sort nums to process in order
            int* sortedNums = (int*)malloc(numsSize * sizeof(int));
            memcpy(sortedNums, nums, numsSize * sizeof(int));
            qsort(sortedNums, numsSize, sizeof(int), compare);
            
            for (int idx = 0; idx < numsSize && valid; idx++) {
                int num = sortedNums[idx];
                while (freq[num + offset] > 0) {
                    int lower = num;
                    int higher = lower + 2 * k;
                    
                    if (higher + offset >= 100001 || freq[higher + offset] <= 0) {
                        valid = 0;
                        break;
                    }
                    
                    original[origIdx++] = lower + k;
                    freq[lower + offset]--;
                    freq[higher + offset]--;
                }
            }
            
            free(sortedNums);
            
            if (valid && origIdx == n) {
                return original;
            }
            
            free(original);
        }
    }
    
    *returnSize = 0;
    return NULL;
}

int main() {
    // Simple input parsing
    int nums[1000];
    int size = 0;
    
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse [1,2,3] format
    char* token = strtok(input, "[,]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = recoverArray(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) possible k values, each requiring O(n) verification time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for frequency map and result array

⚡ Linearithmic Space

Constraints

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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Possible k Values) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler