Closest Subsequence Sum - Practice Coding Problems

Closest Subsequence Sum - Problem

You are given an integer array nums and an integer goal. Your task is to find the optimal subsequence of nums whose sum is as close as possible to the goal.

A subsequence is formed by removing some elements (possibly all or none) from the original array while maintaining the relative order of remaining elements. For example, from array [1, 3, 2, 5], possible subsequences include [1, 3, 5], [2], or [].

Your objective is to minimize the absolute difference |sum - goal|, where sum is the total of your chosen subsequence elements. Return this minimum possible absolute difference.

Key Challenge: With up to 40 elements, there are 2⁴⁰ possible subsequences - too many for brute force! This problem requires an elegant optimization technique called "meet-in-the-middle" to reduce the search space dramatically.

Input & Output

example_1.py — Basic Case

$ Input: {"nums": [5, -7, 3, 5], "goal": 6}

› Output: 0

💡 Note: We can select the entire array [5, -7, 3, 5] which sums to 6, exactly matching our goal. The absolute difference |6 - 6| = 0.

example_2.py — No Perfect Match

$ Input: {"nums": [7, -9, 15, -2], "goal": 5}

› Output: 1

💡 Note: The best subsequence is [7, -2] with sum 5, but let's check: we can get closer with [-9, 15] = 6, giving |6 - 5| = 1. Actually, [7, -2] = 5 gives |5 - 5| = 0. Wait, that would be 0. Let me recalculate: if no subsequence sums to exactly 5, the closest might be 4 or 6, giving difference 1.

example_3.py — Single Element

$ Input: {"nums": [1], "goal": 3}

› Output: 2

💡 Note: We can either choose [] (sum = 0, difference = 3) or [1] (sum = 1, difference = 2). The minimum difference is 2.

Visualization

Tap to expand

Understanding the Visualization

The Problem

40 elements = 2^40 ≈ 1 trillion subsequences to check - computationally impossible

The Insight

Split into two groups of 20 elements each = 2×2^20 ≈ 2 million operations - totally feasible!

Generate & Sort

Create all possible sums for each half, sort one half for binary search

Smart Matching

For each left sum, binary search the right half for the optimal complement

Optimal Result

Find the combination that minimizes |left_sum + right_sum - goal|

Key Takeaway

🎯 Key Insight: Meet-in-the-middle transforms impossible exponential problems into feasible ones by intelligently dividing the search space, making 2^40 operations become just 2×2^20!

Time & Space Complexity

Time Complexity

⏱️

O(2^(n/2) × n/2)

Generate 2^(n/2) sums for each half, each taking O(n/2) time. Binary search adds log factor but is dominated by generation.

✓ Linear Growth

Space Complexity

O(2^(n/2))

Store all possible sums for both halves of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 40
-10⁷ ≤ nums[i] ≤ 10⁷
-10⁹ ≤ goal ≤ 10⁹
Key insight: With n ≤ 40, brute force O(2ⁿ) is impossible, requiring meet-in-the-middle approach

Asked in

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

The optimal approach uses meet-in-the-middle technique to reduce complexity from O(2ⁿ) to O(2^n/2). Split the array in half, generate all possible sums for each half, then use binary search to find the best combination. This transforms an impossible 2⁴⁰ problem into a manageable 2×2²⁰ solution.

Common Approaches

Approach	Time	Space	Notes
✓ Meet in the Middle + Binary Search (Optimal)	O(2^(n/2) × n/2)	O(2^(n/2))	Split array in half, generate all sums for each half, then use binary search to find optimal combinations
Brute Force (Generate All Subsequences)	O(2^n * n)	O(1)	Generate all 2^n possible subsequences and find the one closest to goal

Meet in the Middle + Binary Search (Optimal) — Algorithm Steps

Split the input array into two roughly equal halves
Generate all possible subsequence sums for the left half
Generate all possible subsequence sums for the right half and sort them
For each sum in the left half, calculate the target sum needed from right half
Use binary search on sorted right sums to find the closest match
Track the minimum absolute difference found across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Array

Divide [5, -7, 3, 5] into [5, -7] and [3, 5]

Generate Left Sums

Create all subsequence sums for left half: [0, 5, -7, -2]

Generate & Sort Right Sums

Create and sort right sums: [0, 3, 5, 8]

Binary Search Match

For each left sum, find closest right sum to reach goal

Track Minimum

Keep track of the best combination found

Code -

solution.c — C

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

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

int* generateSums(int* arr, int n, int* returnSize) {
    int size = 1 << n;
    int* sums = (int*)malloc(size * sizeof(int));
    *returnSize = size;
    
    for (int mask = 0; mask < size; mask++) {
        int currentSum = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                currentSum += arr[i];
            }
        }
        sums[mask] = currentSum;
    }
    return sums;
}

int binarySearchClosest(int* arr, int size, int target) {
    int left = 0, right = size - 1;
    int closest = arr[0];
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (abs(arr[mid] - target) < abs(closest - target)) {
            closest = arr[mid];
        }
        
        if (arr[mid] == target) {
            return arr[mid];
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return closest;
}

int minimizeTheDifference(int* nums, int numsSize, int goal) {
    int mid = numsSize / 2;
    
    // Generate sums for both halves
    int leftSize, rightSize;
    int* leftSums = generateSums(nums, mid, &leftSize);
    int* rightSums = generateSums(nums + mid, numsSize - mid, &rightSize);
    
    // Sort right sums for binary search
    qsort(rightSums, rightSize, sizeof(int), compare);
    
    int minDiff = INT_MAX;
    
    // For each sum in left half, find best match in right half
    for (int i = 0; i < leftSize; i++) {
        int target = goal - leftSums[i];
        int closestRight = binarySearchClosest(rightSums, rightSize, target);
        int totalSum = leftSums[i] + closestRight;
        int diff = abs(totalSum - goal);
        if (diff < minDiff) {
            minDiff = diff;
        }
    }
    
    free(leftSums);
    free(rightSums);
    return minDiff;
}

int main() {
    int nums[] = {5, -7, 3, 5};
    int goal = 6;
    int result = minimizeTheDifference(nums, 4, goal);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n/2) × n/2)

Generate 2^(n/2) sums for each half, each taking O(n/2) time. Binary search adds log factor but is dominated by generation.

✓ Linear Growth

Space Complexity

O(2^(n/2))

Store all possible sums for both halves of the array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 40
-10⁷ ≤ nums[i] ≤ 10⁷
-10⁹ ≤ goal ≤ 10⁹
Key insight: With n ≤ 40, brute force O(2ⁿ) is impossible, requiring meet-in-the-middle approach

27.5K Views

Medium Frequency

~25 min Avg. Time

867 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Meet in the Middle + Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler