Number of Ways to Split a String - Practice Coding Problems

Number of Ways to Split a String - Problem

Math String Medium

Split Binary String Into Equal Parts

You're given a binary string s containing only '0's and '1's. Your task is to split this string into exactly 3 non-empty substrings such that each substring contains the same number of ones.

More formally, find the number of ways to split s into s1 + s2 + s3 where:
• Each substring is non-empty
• The count of '1's in s1 equals the count of '1's in s2 equals the count of '1's in s3

Example: For string "10101", we need each part to have exactly 1 one, so valid splits include: "1|01|01", "1|010|1", "10|1|01", "101|0|1"

Since the result can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case with equal distribution

$ Input: s = "10101"

› Output: 4

💡 Note: We need each part to have 1 one. Valid splits: "1|01|01" (positions 1,3), "1|010|1" (positions 1,4), "10|1|01" (positions 2,3), "101|0|1" (positions 3,4). Total: 4 ways.

example_2.py — All zeros edge case

$ Input: s = "1111"

› Output: 0

💡 Note: We have 4 ones total. Since 4 is not divisible by 3, it's impossible to split into 3 parts with equal number of ones. Return 0.

example_3.py — String with only zeros

$ Input: s = "0000"

› Output: 3

💡 Note: All parts will have 0 ones regardless of how we split. We need to choose 2 cut positions from 3 possible positions (after positions 1, 2, or 3). This gives us C(3,2) = 3 ways: "0|0|00", "0|00|0", "00|0|0".

Constraints

3 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'
The string must be split into exactly 3 non-empty parts

Visualization

Tap to expand

Understanding the Visualization

Count the Chips

First count all chocolate chips (ones) in the dough roll

Check Divisibility

If chips can't be divided equally by 3, it's impossible

Find Required Boundaries

Identify where certain chips must be to ensure equal distribution

Count Flexible Zones

Between required chip positions, count the plain dough (zeros) where cuts can be made

Calculate Combinations

Multiply the flexibility in each cutting zone to get total possibilities

Key Takeaway

🎯 Key Insight: Once we know where the required chocolate chips (ones) must be positioned, we only need to count the flexible cutting zones (zeros) between them and multiply the possibilities!

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a mathematical approach: count total ones, check if divisible by 3, then find the flexible cutting zones between required one positions. The key insight is that we only need to multiply the number of possible positions for each cut. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Approach (Optimal)	O(n)	O(1)	Count total ones, find required boundaries, and calculate combinations
Brute Force (Try All Splits)	O(n³)	O(1)	Try every possible way to split the string into 3 parts and count ones

Mathematical Approach (Optimal) — Algorithm Steps

Count total ones in the string
If total ones not divisible by 3, return 0
If all zeros, return C(n-1, 2) = (n-1)(n-2)/2
Find positions of the (ones_per_part)th, (2*ones_per_part)th, and (2*ones_per_part+1)th ones
Count zeros between these boundary positions
Multiply the counts to get total combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Total Ones

Count all ones and check if divisible by 3

Find Boundaries

Locate positions of key ones that define part boundaries

Count Flexibility

Count zeros between boundaries - these are flexible cut positions

Multiply Combinations

Multiply the number of ways for each cut position

Code -

solution.c — C

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

int numWays(char* s) {
    int n = strlen(s);
    const int MOD = 1000000007;
    
    // Count total ones
    int totalOnes = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '1') totalOnes++;
    }
    
    // If not divisible by 3, impossible
    if (totalOnes % 3 != 0) {
        return 0;
    }
    
    // If all zeros, choose 2 positions from n-1 possible cuts
    if (totalOnes == 0) {
        long long ways = (long long)(n - 1) * (n - 2) / 2;
        return ways % MOD;
    }
    
    int onesPerPart = totalOnes / 3;
    
    // Find positions of ones
    int positions[totalOnes];
    int posCount = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] == '1') {
            positions[posCount++] = i;
        }
    }
    
    // Find boundaries
    int firstEnd = positions[onesPerPart - 1];
    int secondStart = positions[onesPerPart];
    int secondEnd = positions[2 * onesPerPart - 1];
    int thirdStart = positions[2 * onesPerPart];
    
    // Count possible positions for cuts
    long long ways1 = secondStart - firstEnd;
    long long ways2 = thirdStart - secondEnd;
    
    return (ways1 * ways2) % MOD;
}

int main() {
    char s[100001];
    scanf("%s", s);
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%d\n", numWays(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count ones and find positions

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space

✓ Linear Space

52.3K Views

Medium Frequency

~18 min Avg. Time

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

Mathematical Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler