Ways to Split Array Into Good Subarrays - Practice Coding Problems

Ways to Split Array Into Good Subarrays - Problem

You're given a binary array nums containing only 0s and 1s. Your task is to find the number of ways to split this array into good subarrays.

A good subarray is defined as a contiguous sequence that contains exactly one element with value 1. You need to partition the entire array such that every subarray in the partition is good.

Return the number of ways to achieve this split. Since the answer can be very large, return it modulo 10⁹ + 7.

Example: For array [0,1,0,0,1], one valid split is [0,1] + [0,0,1] where each part contains exactly one 1.

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: There are 3 ways to split: [0,1] + [0,0,1], [0,1,0] + [0,1], and [0,1,0,0] + [1]. Each subarray contains exactly one 1.

example_2.py — Single element

$ Input: [1]

› Output: 1

💡 Note: Only one way to split: the entire array [1] itself, which contains exactly one 1.

example_3.py — No ones

$ Input: [0,0,0]

› Output: 0

💡 Note: Impossible to create good subarrays since there are no 1s in the array.

Visualization

Tap to expand

Understanding the Visualization

Identify flowers

Find all positions with flowers (1s) in the garden

Count empty spaces

Between each pair of consecutive flowers, count empty spaces (0s)

Calculate fence positions

Each empty space gives us one additional choice for fence placement

Multiply possibilities

Total ways = product of (empty_spaces + 1) for each flower pair

Key Takeaway

🎯 Key Insight: The mathematical pattern emerges from recognizing that splits can only occur between consecutive 1s, and each zero between them provides an additional choice point.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to find 1s and count zeros between them

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Return the result modulo 10⁹ + 7

Asked in

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

The optimal solution uses a mathematical approach to count the ways to split the array. Key insight: between each pair of consecutive 1s, if there are k zeros, we have (k+1) ways to place the split. The final answer is the product of all such possibilities.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Partitions)	O(2^n)	O(n)	Generate all possible ways to partition the array and check if each partition is valid
Math Approach (Optimal)	O(n)	O(1)	Calculate the result using the mathematical insight about zeros between consecutive ones

Brute Force (Generate All Partitions) — Algorithm Steps

Use recursion to generate all possible partitions of the array
For each partition, check if every subarray contains exactly one 1
Count valid partitions and return the count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with full array

Begin with the complete array [0,1,0,0,1]

Try first split position

Split after index 0: [0] | [1,0,0,1]

Continue splitting recursively

For each part, try all possible further splits

Validate each complete partition

Check if each subarray contains exactly one 1

Code -

solution.c — C

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

#define MOD 1000000007

int isGoodSubarray(int* arr, int len) {
    int sum = 0;
    for (int i = 0; i < len; i++) {
        sum += arr[i];
    }
    return sum == 1;
}

int backtrack(int* nums, int n, int start) {
    if (start == n) return 1;
    
    int result = 0;
    for (int end = start; end < n; end++) {
        if (isGoodSubarray(nums + start, end - start + 1)) {
            result = (result + backtrack(nums, n, end + 1)) % MOD;
        }
    }
    
    return result;
}

int numberOfGoodSubarraySplits(int* nums, int n) {
    return backtrack(nums, n, 0);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate 2^(n-1) possible partitions, and for each we verify validity in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space to store current partition

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Return the result modulo 10⁹ + 7

32.4K Views

Medium Frequency

~18 min Avg. Time

956 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 (Generate All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler