Closest Subsequence Sum

Closest Subsequence Sum - Problem

You are given an integer array nums and an integer goal.

You want to choose a subsequence of nums such that the sum of its elements is the closest possible to goal. That is, if the sum of the subsequence's elements is sum, then you want to minimize the absolute difference abs(sum - goal).

Return the minimum possible value of abs(sum - goal).

Note that a subsequence of an array is an array formed by removing some elements (possibly all or none) of the original array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [5,-7,3,5], goal = 6

› Output: 0

💡 Note: We can choose subsequence [5,3] which sums to 8. The difference |8-6| = 2. However, we can also choose [5] which sums to 5, giving |5-6| = 1. Actually, we can choose [3,5] to get sum 8 with difference 2, or just [5] for sum 5 with difference 1, but the optimal is choosing [-7,5,5,3] to get sum 6 with difference 0.

Example 2 — Small Array

$ Input: nums = [7,-9,15], goal = 5

› Output: 1

💡 Note: We can choose subsequence [7,-9,15] with sum 13, difference |13-5| = 8. Or choose [7] with sum 7, difference |7-5| = 2. Or choose [7,-9] with sum -2, difference |-2-5| = 7. The best choice is [15,-9] = 6 with difference |6-5| = 1.

Example 3 — Single Element

$ Input: nums = [1], goal = -7

› Output: 7

💡 Note: We can choose empty subsequence (sum=0) with difference |0-(-7)| = 7, or choose [1] with difference |1-(-7)| = 8. The minimum is 7.

Constraints

1 ≤ nums.length ≤ 40
-10⁷ ≤ nums[i] ≤ 10⁷
-10⁷ ≤ goal ≤ 10⁷

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to use meet-in-the-middle technique to reduce exponential complexity. Split array in half, generate all possible sums for each half, then use binary search to find optimal combinations. Best approach is Meet in the Middle. Time: O(2^(n/2) * log(2^(n/2))), Space: O(2^(n/2))

Common Approaches

✓ Brute Force - Try All Subsequences

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

Use bit manipulation to generate all 2^n possible subsequences. For each subsequence, calculate its sum and track the minimum difference with the goal.

Meet in the Middle

⏱️ Time: O(2^(n/2) * log(2^(n/2))) Space: O(2^(n/2))

Divide the array into two halves. Generate all possible sums for each half (2^(n/2) each). For each sum in the first half, use binary search to find the closest sum in the second half.

Brute Force - Try All Subsequences — Algorithm Steps

Step 1: Generate all 2^n subsequences using bit masks
Step 2: Calculate sum for each subsequence
Step 3: Track minimum abs(sum - goal)

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

Array [5,-7,3,5] with goal 6

Generate

Try all 2^4 = 16 subsequences

Result

Find minimum difference

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int goal) {
    int minDiff = INT_MAX;
    
    // Try all 2^n subsequences
    for (int mask = 0; mask < (1 << numsSize); mask++) {
        int currentSum = 0;
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                currentSum += nums[i];
            }
        }
        
        int diff = abs(currentSum - goal);
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    
    return minDiff;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int goal;
    scanf("%d", &goal);
    
    int result = solution(nums, numsSize, goal);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsequences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.0K 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 Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler