Split Array with Equal Sum - Practice Coding Problems

Split Array with Equal Sum - Problem

Split Array with Equal Sum - The Quadruple Balance Challenge

You're given an integer array nums and need to find if it's possible to split it into four subarrays with equal sums using three strategic split points.

🎯 Your Mission: Find three indices i, j, k such that:
• 0 < i < i+1 < j < j+1 < k < n-1 (proper spacing between splits)
• All four resulting subarrays have identical sums

The four subarrays are:
1. [0...i-1] - Left segment
2. [i+1...j-1] - Left-middle segment
3. [j+1...k-1] - Right-middle segment
4. [k+1...n-1] - Right segment

Note that elements at positions i, j, and k act as separators and are not included in any subarray sum.

Input & Output

example_1.py — Basic Valid Split

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

› Output: true

💡 Note: We can split at positions i=1, j=3, k=5. This gives us four segments: [1] (sum=1), [1] (sum=1), [1] (sum=1), [1] (sum=1). All segments have equal sum of 1.

example_2.py — No Valid Split

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

› Output: false

💡 Note: No matter how we place the three separators, we cannot create four segments with equal sums. The array has an ascending pattern that makes equal splits impossible.

example_3.py — Edge Case Too Short

$ Input: [1,1,1,1]

› Output: false

💡 Note: The array is too short. We need at least 7 elements to place 3 separators with proper spacing constraints (0 < i, i+1 < j, j+1 < k < n-1).

Visualization

Tap to expand

Understanding the Visualization

Setup Prefix Sums

Create a cumulative weight system for instant segment weight calculation

Fix Middle Fulcrum

Choose the middle balance point j and work outward

Map Left Combinations

Find all left segment pairs that balance and store their weights

Match Right Combinations

For each balanced right pair, check if a matching left weight exists

Key Takeaway

🎯 Key Insight: By fixing the middle separator j, we transform a complex 3D search into efficient 2D matching using hash tables and prefix sums.

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n³) for three nested loops × O(n) for calculating each segment sum

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2000
-10⁶ ≤ nums[i] ≤ 10⁶
Array must have at least 7 elements for valid split
Each separator position must maintain proper spacing

Asked in

G Google 28 a Amazon 19 f Meta 15 ⊞ Microsoft 12

The optimal approach uses prefix sums for O(1) range queries and fixes the middle separator j to reduce the problem complexity. For each j, we collect valid left segment sums in a hash set, then check if any right segment sum matches. This achieves O(n²) time complexity, much better than the O(n⁴) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n⁴)	O(1)	Try all possible combinations of three split points and check if resulting segments have equal sums
Two-Pass with Hash Table Optimization	O(n²)	O(n)	First pass builds a map of possible left segments, second pass checks right segments against the map

Brute Force (Triple Nested Loops) — Algorithm Steps

Generate all valid triplets (i, j, k) with proper spacing constraints
For each triplet, calculate the sum of all four segments
Check if all four sums are equal
Return true if any valid triplet is found, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Split (i)

Try each valid position for the first divider

Choose Second Split (j)

For each i, try all valid positions for second divider

Choose Third Split (k)

For each (i,j), try all valid positions for third divider

Calculate & Compare

Calculate all four segment sums and check equality

Code -

solution.c — C

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

int getSum(int* nums, int start, int end) {
    int sum = 0;
    for (int i = start; i <= end; i++) {
        sum += nums[i];
    }
    return sum;
}

bool splitArray(int* nums, int n) {
    if (n < 7) return false;
    
    for (int i = 1; i < n-5; i++) {
        for (int j = i+2; j < n-3; j++) {
            for (int k = j+2; k < n-1; k++) {
                int sum1 = getSum(nums, 0, i-1);
                int sum2 = getSum(nums, i+1, j-1);
                int sum3 = getSum(nums, j+1, k-1);
                int sum4 = getSum(nums, k+1, n-1);
                
                if (sum1 == sum2 && sum2 == sum3 && sum3 == sum4) {
                    return true;
                }
            }
        }
    }
    return false;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    printf("%s\n", splitArray(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n³) for three nested loops × O(n) for calculating each segment sum

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2000
-10⁶ ≤ nums[i] ≤ 10⁶
Array must have at least 7 elements for valid split
Each separator position must maintain proper spacing

28.4K Views

Medium-High Frequency

~25 min Avg. Time

847 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler