Find Array Given Subset Sums - Practice Coding Problems

Find Array Given Subset Sums - Problem

The Mystery Array Detective Challenge

Imagine you're a data detective who needs to reconstruct a lost array from clues! You have an integer n representing the length of an unknown array, and you've been given an array sums containing all possible subset sums of this mystery array.

Here's the twist: the sums array contains exactly 2ⁿ values - one for each possible subset (including the empty subset with sum 0). Your mission is to reverse-engineer the original array from these subset sums.

Example: If the original array was [1, 3], the subset sums would be:
• Empty subset: 0
• Subset [1]: 1
• Subset [3]: 3
• Subset [1,3]: 4
So sums = [0, 1, 3, 4] (in any order)

Can you crack the code and find the original array?

Input & Output

example_1.py — Basic Case

$ Input: n = 3, sums = [0,0,5,5,4,-1,4,-1]

› Output: [2, 3, -1]

💡 Note: The original array [2, 3, -1] generates these subset sums: {} = 0, {2} = 2 (not in sums as given), {3} = 3, {-1} = -1, {2,3} = 5, {2,-1} = 1 (not shown), {3,-1} = 2 (not shown), {2,3,-1} = 4. The sums array contains all these values with possible duplicates.

example_2.py — Simple Two Elements

$ Input: n = 2, sums = [0,2,3,5]

› Output: [2, 3]

💡 Note: Array [2, 3] produces subset sums: {} = 0, {2} = 2, {3} = 3, {2,3} = 5. This perfectly matches the given sums array.

example_3.py — Single Element

$ Input: n = 1, sums = [0,7]

› Output: [7]

💡 Note: With only one element, the subset sums are: {} = 0 and {7} = 7. So the original array must be [7].

Constraints

1 ≤ n ≤ 15
sums.length == 2ⁿ
-10⁴ ≤ sums[i] ≤ 10⁴
Important: There is always exactly one valid solution

Visualization

Tap to expand

Understanding the Visualization

Identify Key Ingredient

Find the cheapest single ingredient (smallest absolute sum) - this must be in our recipe

Separate Combinations

Split all combinations into those with/without our key ingredient

Recurse on Remainder

Apply the same process to find remaining ingredients

Combine Results

Build the complete recipe by combining all discovered ingredients

Key Takeaway

🎯 Key Insight: The smallest absolute non-zero subset sum must be an element of the original array. This allows us to partition and conquer recursively!

Asked in

G Google 15 f Meta 12 ⊞ Microsoft 8 a Amazon 6

The optimal solution uses divide and conquer with a key insight: the smallest absolute non-zero value in the sums array must be an element of the original array. We can then partition the sums into two groups (with/without this element) and recursively solve for the remaining elements. This achieves O(n × 2^n) time complexity, which is optimal since we must process all 2^n subset sums.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(k^n * 2^n)	O(2^n)	Try all possible arrays and check if their subset sums match
Divide and Conquer (Optimal)	O(n × 2^n)	O(2^n)	Split sums into two groups and recursively recover array elements

Brute Force (Generate All Combinations) — Algorithm Steps

Generate all possible arrays of length n with reasonable value ranges
For each candidate array, compute all 2^n subset sums
Sort both the computed sums and given sums
If they match exactly, return the candidate array
Continue until a match is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Candidate Array

Try array [a, b, c] with all possible values

Compute All Subset Sums

Calculate sums for [], [a], [b], [c], [a,b], [a,c], [b,c], [a,b,c]

Compare with Target

Check if computed sums match the given sums array

Code -

solution.c — C

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

int* result;
int found = 0;

void getSubsetSums(int* arr, int n, int* sums) {
    int idx = 0;
    for (int mask = 0; mask < (1 << n); mask++) {
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                sum += arr[i];
            }
        }
        sums[idx++] = sum;
    }
}

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

int checkMatch(int* computed, int* target, int size) {
    qsort(computed, size, sizeof(int), compare);
    qsort(target, size, sizeof(int), compare);
    
    for (int i = 0; i < size; i++) {
        if (computed[i] != target[i]) {
            return 0;
        }
    }
    return 1;
}

void generateArrays(int* current, int pos, int n, int minVal, int maxVal, int* targetSums, int targetSize) {
    if (found) return;
    
    if (pos == n) {
        int* subsetSums = (int*)malloc(targetSize * sizeof(int));
        getSubsetSums(current, n, subsetSums);
        
        if (checkMatch(subsetSums, targetSums, targetSize)) {
            for (int i = 0; i < n; i++) {
                result[i] = current[i];
            }
            found = 1;
        }
        free(subsetSums);
        return;
    }
    
    for (int val = minVal; val <= maxVal && !found; val++) {
        current[pos] = val;
        generateArrays(current, pos + 1, n, minVal, maxVal, targetSums, targetSize);
    }
}

int* recoverArray(int n, int* sums, int sumsSize) {
    result = (int*)malloc(n * sizeof(int));
    found = 0;
    
    int minSum = sums[0], maxSum = sums[0];
    for (int i = 0; i < sumsSize; i++) {
        if (sums[i] < minSum) minSum = sums[i];
        if (sums[i] > maxSum) maxSum = sums[i];
    }
    
    int* current = (int*)malloc(n * sizeof(int));
    generateArrays(current, 0, n, minSum, maxSum, sums, sumsSize);
    
    free(current);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int sumsSize = 1 << n;
    int* sums = (int*)malloc(sumsSize * sizeof(int));
    
    for (int i = 0; i < sumsSize; i++) {
        scanf("%d", &sums[i]);
    }
    
    int* answer = recoverArray(n, sums, sumsSize);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(", ");
        printf("%d", answer[i]);
    }
    printf("]\n");
    
    free(sums);
    free(answer);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k^n * 2^n)

k^n possible arrays to try, 2^n subset sums to compute for each

⚠ Quadratic Growth

Space Complexity

O(2^n)

Space to store subset sums for verification

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

847 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler