Number of Good Ways to Split a String - Practice Coding Problems

Number of Good Ways to Split a String - Problem

You are given a string s and need to find all the "good" ways to split it into two parts.

A split is considered good if:

You can split s into two non-empty strings s_left and s_right
Their concatenation equals the original string: s_left + s_right = s
The number of distinct characters in s_left equals the number of distinct characters in s_right

Goal: Return the total count of good splits possible.

Example: For string "aacaba", we can split it as "aa|caba" (2 distinct chars each) or "aac|aba" (2 distinct chars each), giving us 2 good splits.

Input & Output

example_1.py — Basic Case

$ Input: s = "aacaba"

› Output: 2

💡 Note: Split at position 3: "aac|aba" gives 2 distinct chars each side. Split at position 4: "aaca|ba" gives 2 distinct chars each side. Total: 2 good splits.

example_2.py — All Same Characters

$ Input: s = "abcd"

› Output: 1

💡 Note: Only one good split at position 2: "ab|cd" gives 2 distinct chars on each side. All other splits have unequal distinct character counts.

example_3.py — Repeated Pattern

$ Input: s = "aaaa"

› Output: 3

💡 Note: All possible splits have 1 distinct character on both sides: "a|aaa", "aa|aa", "aaa|a". Total: 3 good splits.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
Both parts must be non-empty after splitting

Visualization

Tap to expand

Understanding the Visualization

Count Left Genres

As we move the divider right, track distinct genres accumulated on the left

Calculate Right Genres

For each position, determine how many distinct genres remain on the right

Compare & Count

Count positions where left distinct genres equal right distinct genres

Key Takeaway

🎯 Key Insight: Pre-computing both prefix and suffix distinct character counts allows us to check each split in constant time, reducing complexity from O(n²) to O(n).

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 15

The optimal solution uses two pre-computed arrays to store distinct character counts for prefixes and suffixes. This allows us to check each split position in O(1) time, achieving overall O(n) time complexity. The key insight is avoiding redundant character counting by processing the string only twice.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Two-Array Approach	O(n)	O(n)	Pre-compute both prefix and suffix distinct counts for O(n) solution
Brute Force (Check All Splits)	O(n²)	O(1)	For each possible split position, count distinct characters in both parts
Two-Pass Optimization	O(n²)	O(n)	Pre-compute prefix distinct counts, then calculate suffix counts efficiently

Optimal Two-Array Approach — Algorithm Steps

Forward pass: Calculate distinct character count for each prefix
Backward pass: Calculate distinct character count for each suffix
For each split position, compare prefix[i-1] with suffix[i]
Count positions where these values are equal
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Forward Pass

Calculate prefix distinct counts from left to right

Backward Pass

Calculate suffix distinct counts from right to left

Compare Arrays

For each split, compare prefix[i-1] with suffix[i] in O(1)

Code -

solution.c — C

int numSplits(char* s) {
    int n = strlen(s);
    
    // Calculate distinct chars for each prefix
    int* leftDistinct = (int*)malloc(n * sizeof(int));
    bool seen[26] = {false};
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (!seen[s[i] - 'a']) {
            seen[s[i] - 'a'] = true;
            count++;
        }
        leftDistinct[i] = count;
    }
    
    // Calculate distinct chars for each suffix
    int* rightDistinct = (int*)malloc(n * sizeof(int));
    memset(seen, false, sizeof(seen));
    count = 0;
    for (int i = n - 1; i >= 0; i--) {
        if (!seen[s[i] - 'a']) {
            seen[s[i] - 'a'] = true;
            count++;
        }
        rightDistinct[i] = count;
    }
    
    // Count good splits
    int result = 0;
    for (int i = 1; i < n; i++) {
        if (leftDistinct[i - 1] == rightDistinct[i]) {
            result++;
        }
    }
    
    free(leftDistinct);
    free(rightDistinct);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Two arrays of size n to store prefix and suffix distinct counts

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~18 min Avg. Time

924 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

Optimal Two-Array Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler