Find Array Given Subset Sums

Find Array Given Subset Sums - Problem

You are given an integer n representing the length of an unknown array that you are trying to recover. You are also given an array sums containing the values of all 2^n subset sums of the unknown array (in no particular order).

Return the array ans of length n representing the unknown array. If multiple answers exist, return any of them.

An array sub is a subset of an array arr if sub can be obtained from arr by deleting some (possibly zero or all) elements of arr. The sum of the elements in sub is one possible subset sum of arr. The sum of an empty array is considered to be 0.

Note: Test cases are generated such that there will always be at least one correct answer.

Input & Output

Example 1 — Basic Case

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

› Output: [1,2,-3]

💡 Note: The array [1,2,-3] generates subset sums: [] = 0, [1] = 1, [2] = 2, [-3] = -3, [1,2] = 3, [1,-3] = -2, [2,-3] = -1, [1,2,-3] = 0. When sorted: [-3,-2,-1,0,0,1,2,3]

Example 2 — Small Array

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

› Output: [0,0]

💡 Note: The array [0,0] generates all zero subset sums: [] = 0, [0] = 0, [0] = 0, [0,0] = 0

Example 3 — Single Element

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

› Output: [5]

💡 Note: The array [5] generates subset sums: [] = 0, [5] = 5

Constraints

1 ≤ n ≤ 15
sums.length == 2ⁿ
-10⁴ ≤ sums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The divide and conquer approach is optimal. Split subset sums into groups based on including/excluding elements. The key insight is that corresponding sums differ by the element value. Best approach uses recursive splitting: Time: O(n × 2^n), Space: O(2^n)

Common Approaches

✓ Brute Force Backtracking

⏱️ Time: O(2^n × 2^n) Space: O(2^n)

Generate all possible arrays of length n, compute their subset sums, and check if they match the given sums array. This involves testing exponentially many possibilities.

Divide and Conquer

⏱️ Time: O(n × 2^n) Space: O(2^n)

The key insight is that subset sums can be split into two groups: those that include a specific element and those that don't. The difference between corresponding sums reveals the element value.

Brute Force Backtracking — Algorithm Steps

Generate all possible arrays of length n
For each array, compute all 2^n subset sums
Check if the computed sums match the given sums

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Candidates

Create all possible arrays of length n

Compute Subset Sums

For each candidate, calculate all 2^n subset sums

Verify Match

Check if computed sums match given sums

Code -

solution.c — C

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

int isSpecial(const char* s, int start, int len) {
    if (len == 0) return 0;
    char first = s[start];
    for (int i = 1; i < len; i++) {
        if (s[start + i] != first) return 0;
    }
    return 1;
}

int solution(const char* s) {
    int n = strlen(s);
    int maxLength = -1;
    
    // For each possible length
    for (int len = 1; len <= n; len++) {
        // Count occurrences of each special substring of this length
        for (int i = 0; i <= n - len; i++) {
            if (isSpecial(s, i, len)) {
                // Count how many times this substring occurs
                int count = 1;
                for (int j = i + 1; j <= n - len; j++) {
                    if (isSpecial(s, j, len)) {
                        // Check if it's the same substring
                        int same = 1;
                        for (int k = 0; k < len; k++) {
                            if (s[i + k] != s[j + k]) {
                                same = 0;
                                break;
                            }
                        }
                        if (same) count++;
                    }
                }
                if (count >= 3 && len > maxLength) {
                    maxLength = len;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[50001];
    scanf("%s", s);
    
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × 2^n)

Try 2^n possible arrays, each requiring 2^n subset sum computations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Store subset sums for verification

⚠ Quadratic Space

23.4K Views

Medium Frequency

~45 min Avg. Time

876 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler