Ways to Split Array Into Three Subarrays - Practice Coding Problems

Ways to Split Array Into Three Subarrays - Problem

Array Partitioning Challenge: You need to find all the valid ways to split an array into exactly three contiguous subarrays such that their sums follow a specific order.

Given an array of non-negative integers, a "good" split must satisfy:
• Split into exactly 3 non-empty contiguous parts: left, mid, right
• sum(left) ≤ sum(mid) ≤ sum(right)

Goal: Count all possible good splits. Since the answer can be large, return it modulo 10^9 + 7.

Example: For [1,1,1], there's only one way to split: [1] | [1] | [1] where 1 ≤ 1 ≤ 1 ✅

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Only one way to split: [1] | [1] | [1]. Sum check: 1 ≤ 1 ≤ 1 ✅

example_2.py — Multiple Valid Splits

$ Input: nums = [1,2,2,2,5,0]

› Output: 3

💡 Note: Valid splits: [1] | [2] | [2,2,5,0] (1≤2≤9), [1] | [2,2] | [2,5,0] (1≤4≤7), [1,2] | [2,2] | [5,0] (3≤4≤5)

example_3.py — No Valid Splits

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

› Output: 0

💡 Note: Only possible split: [3] | [2] | [1]. Sum check: 3 ≤ 2 ≤ 1 ❌ (first condition fails)

Visualization

Tap to expand

Understanding the Visualization

Build Foundation

Create prefix sums for instant subarray sum calculation

Fix Left Team

For each possible left team size, find valid middle team ranges

Smart Search

Use binary search to efficiently find minimum and maximum valid middle positions

Count Solutions

Add the count of valid positions in the found range

Key Takeaway

🎯 Key Insight: Instead of checking every possible middle position (O(n²)), use binary search to find the valid range boundaries efficiently (O(n log n))!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop O(n) for left sizes, inner two-pointer search O(n) for each left

⚠ Quadratic Growth

Space Complexity

O(n)

Prefix sum array requires O(n) additional space

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁴
All elements are non-negative integers
Array must be split into exactly 3 non-empty contiguous subarrays

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses prefix sums with binary search to achieve O(n log n) time complexity. Key insight: for each fixed left subarray, there's a range of valid middle subarray positions - use binary search to find this range efficiently rather than checking each position individually.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Two Pointers	O(n²)	O(n)	Use prefix sums and two pointers to efficiently find valid split ranges
Prefix Sum + Binary Search (Optimal)	O(n log n)	O(n)	Use prefix sums with binary search to efficiently find valid mid subarray boundaries
Brute Force (Triple Nested Approach)	O(n³)	O(1)	Try all possible split positions and calculate sums for each combination

Prefix Sum + Two Pointers — Algorithm Steps

Build prefix sum array for O(1) subarray sum calculation
For each possible left subarray size, find valid mid ranges
Use two pointers to find minimum and maximum valid mid positions
Count valid splits: max_mid - min_mid + 1 for each left size

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Left

Fix the left subarray size and calculate its sum

Find Min Mid

Find minimum mid position where sum(mid) ≥ sum(left)

Find Max Mid

Find maximum mid position where sum(mid) ≤ sum(right)

Count Range

Count valid positions in range [min_mid, max_mid)

Code -

solution.c — C

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

int waysToSplit(int* nums, int n) {
    const int MOD = 1000000007;
    
    // Build prefix sum array
    long long* prefix = (long long*)calloc(n + 1, sizeof(long long));
    for (int i = 0; i < n; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    int count = 0;
    
    for (int i = 1; i < n - 1; i++) {
        long long leftSum = prefix[i];
        
        // Find minimum j such that sum(mid) >= sum(left)
        int minJ = i + 1;
        while (minJ < n && prefix[minJ] - prefix[i] < leftSum) {
            minJ++;
        }
        
        // Find maximum j such that sum(mid) <= sum(right)
        int maxJ = minJ;
        while (maxJ < n) {
            long long midSum = prefix[maxJ] - prefix[i];
            long long rightSum = prefix[n] - prefix[maxJ];
            if (midSum <= rightSum) {
                maxJ++;
            } else {
                break;
            }
        }
        
        if (minJ < maxJ && maxJ <= n) {
            count = (count + maxJ - minJ) % MOD;
        }
    }
    
    free(prefix);
    return count;
}

int main() {
    int nums[100000];
    int n = 0;
    int num;
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
    }
    printf("%d\n", waysToSplit(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop O(n) for left sizes, inner two-pointer search O(n) for each left

⚠ Quadratic Growth

Space Complexity

O(n)

Prefix sum array requires O(n) additional space

⚡ Linearithmic Space

Constraints

3 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁴
All elements are non-negative integers
Array must be split into exactly 3 non-empty contiguous subarrays

52.1K Views

Medium Frequency

~25 min Avg. Time

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

Prefix Sum + Two Pointers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler