Split Array With Same Average

Split Array With Same Average - Problem

You are given an integer array nums. You should move each element of nums into one of the two arrays A and B such that A and B are non-empty, and average(A) == average(B).

Return true if it is possible to achieve that and false otherwise.

Note: For an array arr, average(arr) is the sum of all the elements of arr over the length of arr.

Input & Output

Example 1 — Possible Split

$ Input: nums = [1,2,3,4,5,6,7,8]

› Output: true

💡 Note: We can split into {1,4,5,8} with average 4.5 and {2,3,6,7} with average 4.5

Example 2 — Impossible Split

$ Input: nums = [3,1]

› Output: false

💡 Note: Cannot split 2 elements into two non-empty groups with same average

Example 3 — Equal Elements

$ Input: nums = [1,1,1,1]

› Output: true

💡 Note: Any split like {1,1} and {1,1} will have the same average of 1.0

Constraints

1 ≤ nums.length ≤ 30
0 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 8 f Facebook 5 M Microsoft 3

The key insight is that if two subsets have equal averages, they both equal the total average. Use dynamic programming to track all possible (sum, count) pairs and check if any valid partition exists. Best approach uses DP with mathematical optimization. Time: O(n × 2ⁿ), Space: O(2ⁿ)

Common Approaches

✓ 2D DP with Bitmask Optimization

⏱️ Time: O(n² × sum) Space: O(n × sum)

Build a 2D DP table where dp[i][j] represents all possible sums achievable using exactly j elements from first i elements. Use bitset for memory efficiency.

Brute Force - Try All Partitions

⏱️ Time: O(2ⁿ) Space: O(n)

For each possible subset of the array, check if it and its complement have the same average. This requires trying all 2^n possible subsets.

Mathematical Optimization with DP

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

Key insight: if avg(A) = avg(B), then both equal the overall average. Use DP to check if we can form subset with specific sum and size.

2D DP with Bitmask Optimization — Algorithm Steps

Create DP table dp[size][sum] = set of possible counts
For each element, update DP by including/excluding it
Check if any valid partition exists with equal averages

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with state (sum=0, count=0)

Process Elements

For each element, create new states by including it

Check Averages

Find states where sum_a/count_a = sum_b/count_b

Code -

solution.c — C

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

#define MAX_N 30
#define MAX_SUMS 100000

static long long dp_sums[MAX_N + 1][MAX_SUMS];
static int dp_count[MAX_N + 1];

bool solution(int* nums, int n) {
    if (n <= 1) return false;
    
    long long totalSum = 0;
    for (int i = 0; i < n; i++) totalSum += nums[i];
    
    // Initialize DP
    for (int i = 0; i <= n; i++) {
        dp_count[i] = 0;
    }
    dp_sums[0][0] = 0;
    dp_count[0] = 1;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        
        // Process in reverse order to avoid using the same element twice
        for (int count = n - 1; count >= 0; count--) {
            if (dp_count[count] > 0) {
                for (int j = 0; j < dp_count[count]; j++) {
                    long long newSum = dp_sums[count][j] + num;
                    
                    // Check if this sum already exists in dp[count+1]
                    bool exists = false;
                    for (int k = 0; k < dp_count[count + 1]; k++) {
                        if (dp_sums[count + 1][k] == newSum) {
                            exists = true;
                            break;
                        }
                    }
                    
                    if (!exists && dp_count[count + 1] < MAX_SUMS) {
                        dp_sums[count + 1][dp_count[count + 1]] = newSum;
                        dp_count[count + 1]++;
                    }
                }
            }
        }
    }
    
    // Check if any partition has equal averages
    for (int countA = 1; countA < n; countA++) {
        int countB = n - countA;
        for (int i = 0; i < dp_count[countA]; i++) {
            long long sumA = dp_sums[countA][i];
            long long sumB = totalSum - sumA;
            
            if (sumA > 0 && sumB > 0 && sumA * countB == sumB * countA) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int nums[MAX_N];
    int n = 0;
    
    // Parse input manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endp;
        nums[n++] = (int)strtol(p, &endp, 10);
        p = endp;
    }
    
    bool result = solution(nums, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × sum)

Iterate through n elements × n possible sizes × sum range

⚠ Quadratic Growth

Space Complexity

O(n × sum)

2D DP table storing possible states

⚡ Linearithmic Space

22.3K Views

Medium Frequency

~45 min Avg. Time

890 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

2D DP with Bitmask Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler