Partition Array Into Two Arrays to Minimize Sum Difference

Partition Array Into Two Arrays to Minimize Sum Difference - Problem

Array Two Pointers Binary Search Dynamic Programming Bit Manipulation Ordered Set Bitmask Hard

You are given an integer array nums of 2 * n integers. You need to partition nums into two arrays of length n to minimize the absolute difference of the sums of the arrays.

To partition nums, put each element of nums into one of the two arrays.

Return the minimum possible absolute difference.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,9,7,3]

› Output: 2

💡 Note: Split into [3,9] and [7,3]. Sum difference is |12-10| = 2, which is minimal.

Example 2 — Perfect Split

$ Input: nums = [-36,36]

› Output: 72

💡 Note: Only two elements, must split as [-36] and [36]. Difference is |-36-36| = 72.

Example 3 — Multiple Options

$ Input: nums = [2,-1,0,4,-2,-9]

› Output: 0

💡 Note: Can split as [2,-1,-2] and [0,4,-9] both summing to -1. Difference is |-1-(-1)| = 0.

Constraints

1 ≤ n ≤ 15
nums.length == 2 * n
-10⁷ ≤ nums[i] ≤ 10⁷

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array of 2n elements that needs equal partitioning

Find Optimal Split

Try different ways to partition into two equal groups

Minimum Difference

Return smallest possible |sum1 - sum2|

Key Takeaway

🎯 Key Insight: Use meet-in-the-middle to reduce exponential search space from O(2^(2n)) to O(3^n)

Asked in

G Google 45 f Facebook 38 M Microsoft 32 a Amazon 28

This problem requires partitioning an array of 2n elements into two equal-sized subsets to minimize sum difference. The key insight is using meet-in-the-middle technique: split the array in half, generate all subset sums for each half, then use binary search to find optimal pairings. Best approach achieves O(3^n) time complexity. Time: O(3^n), Space: O(2^n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Combinations	O(2^(2n))	O(n)	Generate all possible ways to choose n elements and find minimum difference
Meet in the Middle with Binary Search	O(3^n)	O(2^n)	Split array in half, generate all subset sums for each half, then use binary search to find optimal pairing

Brute Force - Try All Combinations — Algorithm Steps

Generate all C(2n, n) combinations of choosing n elements
For each combination, calculate sum of chosen vs remaining elements
Track the minimum absolute difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all ways to choose n elements

Calculate Difference

For each split, find |sum1 - sum2|

Find Minimum

Keep track of smallest difference

Code -

solution.c — C

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

int findMinDiff(int* nums, int size, int index, int sum1, int count1, int target, int totalSum) {
    if (count1 == target) {
        int diff = sum1 - (totalSum - sum1);
        return diff < 0 ? -diff : diff;
    }
    
    if (index >= size) {
        return INT_MAX;
    }
    
    // Include current element
    int include = findMinDiff(nums, size, index + 1, sum1 + nums[index], count1 + 1, target, totalSum);
    
    // Exclude current element
    int exclude = INT_MAX;
    if (size - index - 1 >= target - count1 - 1) {
        exclude = findMinDiff(nums, size, index + 1, sum1, count1, target, totalSum);
    }
    
    return include < exclude ? include : exclude;
}

int solution(int* nums, int size) {
    int n = size / 2;
    int totalSum = 0;
    for (int i = 0; i < size; i++) {
        totalSum += nums[i];
    }
    return findMinDiff(nums, size, 0, 0, 0, n, totalSum);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[100];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(2n))

Need to check all C(2n,n) combinations which is exponential

✓ Linear Growth

Space Complexity

O(n)

Space for storing current combination and recursion stack

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~45 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 Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler