Split Array With Same Average - Practice Coding Problems

Split Array With Same Average - Problem

Given an integer array nums, you need to determine if it's possible to split the array into two non-empty groups such that both groups have the same average.

Think of this as dividing a class of students with different test scores into two groups where both groups have identical average scores. You must move each student to exactly one of the two groups, and both groups must have at least one student.

Goal: Return true if such a split is possible, false otherwise.

Note: The average of an array is the sum of all elements divided by the length of the array.

Example: For nums = [1,2,3,4,5,6,7,8], we can split into [1,4,5,8] and [2,3,6,7]. Both groups have average 4.5!

Input & Output

example_1.py — Basic Split

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

› Output: true

💡 Note: We can split into [1,4,5,8] (sum=18, avg=4.5) and [2,3,6,7] (sum=18, avg=4.5). Both groups have the same average of 4.5.

example_2.py — Impossible Split

$ Input: [3,1]

› Output: false

💡 Note: We can only split into [3] (avg=3) and [1] (avg=1). Since 3 ≠ 1, it's impossible to achieve equal averages.

example_3.py — Multiple Valid Splits

$ Input: [1,2,3,4]

› Output: false

💡 Note: Total sum is 10. For equal averages, we need sum₁/size₁ = sum₂/size₂ = 2.5. But with integers, we can't achieve fractional sums, so it's impossible.

Visualization

Tap to expand

Understanding the Visualization

Understand the constraint

For equal averages: sum₁/size₁ = sum₂/size₂ = total_sum/n

Derive the formula

This means sum₁ = (total_sum × size₁) / n must be an integer

Check feasibility

For each possible group size k, check if (total_sum × k) % n == 0

Use dynamic programming

If feasible, use DP to check if we can actually form such a subset

Key Takeaway

🎯 Key Insight: Equal averages occur when subset sum equals (total_sum × subset_size) ÷ array_length. Use math to find targets, then DP to verify feasibility!

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets of the array

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space for storing current subset

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 30
0 ≤ nums[i] ≤ 10⁴
Both groups must be non-empty
The average is calculated as sum of elements divided by count

Asked in

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

The key insight is that two groups have equal averages if and only if one group's sum equals (total_sum × group_size) ÷ total_length. We use this mathematical constraint to determine possible target sums, then apply dynamic programming to check if such subsets can be formed. The optimal approach runs in O(n² × sum) time by only checking subset sizes up to n/2.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsets)	O(2^n)	O(n)	Generate all possible subsets and check if any has the required average
Mathematical Insight + Dynamic Programming	O(n² * sum)	O(n * sum)	Use mathematical constraints to reduce search space, then apply dynamic programming

Brute Force (Try All Subsets) — Algorithm Steps

Generate all possible non-empty subsets of the array
For each subset, calculate its average
Calculate the average of remaining elements
Check if both averages are equal
Return true if any split works, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty subset

Begin with no elements selected for subset A

For each element, try both choices

Include in subset A or exclude (put in subset B)

Calculate averages

When we reach the end, calculate averages of both subsets

Check equality

Return true if averages are equal, continue searching otherwise

Code -

solution.c — C

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

int backtrack(int* nums, int index, int subsetSum, int subsetSize, int totalSum, int n) {
    if (index == n) {
        if (subsetSize > 0 && subsetSize < n) {
            double avg1 = (double) subsetSum / subsetSize;
            double avg2 = (double) (totalSum - subsetSum) / (n - subsetSize);
            return fabs(avg1 - avg2) < 1e-9;
        }
        return 0;
    }
    
    // Include current element
    if (backtrack(nums, index + 1, subsetSum + nums[index], subsetSize + 1, totalSum, n)) {
        return 1;
    }
    
    // Exclude current element
    return backtrack(nums, index + 1, subsetSum, subsetSize, totalSum, n);
}

int splitArraySameAverage(int* nums, int numsSize) {
    int totalSum = 0;
    for (int i = 0; i < numsSize; i++) {
        totalSum += nums[i];
    }
    return backtrack(nums, 0, 0, 0, totalSum, numsSize);
}

int main() {
    int nums[] = {1, 2, 3, 4, 5, 6, 7, 8};
    int size = sizeof(nums) / sizeof(nums[0]);
    printf("%s\n", splitArraySameAverage(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsets of the array

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space for storing current subset

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 30
0 ≤ nums[i] ≤ 10⁴
Both groups must be non-empty
The average is calculated as sum of elements divided by count

33.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Subsets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler