Recover the Original Array

Recover the Original Array - Problem

Alice had a 0-indexed array arr consisting of n positive integers. She chose an arbitrary positive integer k and created two new 0-indexed integer arrays lower and higher in the following manner:

lower[i] = arr[i] - k, for every index i where 0 <= i < n
higher[i] = arr[i] + k, for every index i where 0 <= i < n

Unfortunately, Alice lost all three arrays. However, she remembers the integers that were present in the arrays lower and higher, but not the array each integer belonged to. Help Alice and recover the original array.

Given an array nums consisting of 2n integers, where exactly n of the integers were present in lower and the remaining in higher, return the original array arr. In case the answer is not unique, return any valid array.

Note: The test cases are generated such that there exists at least one valid array arr.

Input & Output

Example 1 — Basic Case

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

› Output: [3,7,5]

💡 Note: If k=2, then lower=[1,5,3] and higher=[5,9,7]. The combined array is [1,5,3,5,9,7]. When sorted: [1,3,5,5,7,9]. Pairing (1,5)→3, (3,7)→5, (5,9)→7 gives original=[3,5,7]. But the actual pairing that works is different - we need to find the right k first.

Example 2 — Simple Pattern

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

› Output: [2,2]

💡 Note: With k=1: lower=[1,1] and higher=[3,3], so original=[2,2]. Each original element 2 creates pair (2-1, 2+1) = (1,3).

Example 3 — Larger Difference

$ Input: nums = [5,435]

› Output: [220]

💡 Note: With k=215: lower=[5] and higher=[435], so original=[220]. Single element case where 220-215=5 and 220+215=435.

Constraints

2 ≤ nums.length ≤ 1000
nums.length is even
-1000 ≤ nums[i] ≤ 1000
The test cases are generated such that there exists at least one valid array arr.

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that the smallest element in the input array must belong to the lower array, allowing us to determine the correct value of k. Best approach uses greedy pairing with frequency counting after sorting. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Possible k Values

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

For each possible k value (derived from pairs of numbers), attempt to reconstruct the original array by pairing lower and higher values. Check if exactly n pairs can be formed.

Optimal Greedy Approach

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

Since the smallest element must belong to the lower array, we can determine the correct k by finding its pair in the higher array. Once k is known, greedily construct the original array.

Optimized Sort-First Approach

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

Sort the input array first. The smallest element must belong to the lower array. Try pairing it with larger elements to find valid k values, then greedily construct the original array.

Brute Force - Try All Possible k Values — Algorithm Steps

Step 1: Try each possible k = (nums[j] - nums[i]) / 2 for all pairs
Step 2: For each k, attempt to pair each number x with x+2k
Step 3: If exactly n pairs found, reconstruct original array as [x+k] for each pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate k candidates

Try k = (nums[j] - nums[i]) / 2 for all pairs

Test each k

For each k, attempt to pair numbers differing by 2k

Validate result

Check if exactly n pairs formed, return original array

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* solution(int* nums, int numsSize, int* returnSize) {
    int n = numsSize / 2;
    qsort(nums, numsSize, sizeof(int), compare);
    
    static int count[200001];
    
    // Try different k values, starting from i=1 for k>0
    for (int i = 1; i < numsSize; i++) {
        if ((nums[i] - nums[0]) % 2 != 0) continue;
        
        int k = (nums[i] - nums[0]) / 2;
        if (k <= 0) continue;
        
        // Try to form pairs with this k
        memset(count, 0, sizeof(count));
        for (int idx = 0; idx < numsSize; idx++) {
            count[nums[idx] + 100000]++;
        }
        
        int* result = (int*)malloc(n * sizeof(int));
        int resultIdx = 0;
        
        // Process in sorted order to ensure consistent pairing
        for (int idx = 0; idx < numsSize && resultIdx < n; idx++) {
            int num = nums[idx];
            while (count[num + 100000] > 0 && count[num + 2 * k + 100000] > 0 && resultIdx < n) {
                result[resultIdx++] = num + k;
                count[num + 100000]--;
                count[num + 2 * k + 100000]--;
            }
        }
        
        if (resultIdx == n) {
            *returnSize = n;
            return result;
        }
        
        free(result);
    }
    
    // If no k>0 works, try k=0 as last resort
    int k = 0;
    memset(count, 0, sizeof(count));
    for (int idx = 0; idx < numsSize; idx++) {
        count[nums[idx] + 100000]++;
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    int resultIdx = 0;
    
    for (int idx = 0; idx < numsSize && resultIdx < n; idx++) {
        int num = nums[idx];
        while (count[num + 100000] >= 2 && resultIdx < n) {
            result[resultIdx++] = num;
            count[num + 100000] -= 2;
        }
    }
    
    if (resultIdx == n) {
        *returnSize = n;
        return result;
    }
    
    free(result);
    *returnSize = 0;
    return NULL;
}
int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[2000];
    int numsSize = 0;
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        nums[numsSize++] = (int)strtol(p, &p, 10);
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Outer loop tries O(n²) possible k values, inner loop takes O(n) to validate each k

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to track used numbers during validation

⚡ Linearithmic Space

28.7K Views

Medium Frequency

~35 min Avg. Time

892 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 - Try All Possible k Values — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler