Number of Good Ways to Split a String

Number of Good Ways to Split a String - Problem

You are given a string s.

A split is called good if you can split s into two non-empty strings s_left and s_right where their concatenation is equal to s (i.e., s_left + s_right = s) and the number of distinct letters in s_left and s_right is the same.

Return the number of good splits you can make in s.

Input & Output

Example 1 — Multiple Good Splits

$ Input: s = "aacaba"

› Output: 2

💡 Note: Split at index 2: "aa" (1 unique: a) | "caba" (3 unique: a,b,c) → 1≠3. Split at index 3: "aac" (2 unique: a,c) | "aba" (2 unique: a,b) → 2=2 ✓. Split at index 5: "aacab" (3 unique: a,c,b) | "a" (1 unique: a) → 3≠1. Only 1 good split, but checking all positions gives us 2 total good splits.

Example 2 — No Good Splits

$ Input: s = "abcd"

› Output: 1

💡 Note: Split at index 1: "a" (1 unique) | "bcd" (3 unique) → 1≠3. Split at index 2: "ab" (2 unique) | "cd" (2 unique) → 2=2 ✓. Split at index 3: "abc" (3 unique) | "d" (1 unique) → 3≠1. There is 1 good split.

Example 3 — All Same Characters

$ Input: s = "aaaa"

› Output: 3

💡 Note: Any split will have 1 unique character on both sides: "a"|"aaa", "aa"|"aa", "aaa"|"a" all have equal unique counts.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to use frequency maps to efficiently track unique character counts. Instead of recalculating character sets for each split, we maintain left and right frequency maps and transfer characters between them. Best approach is two-pass hash with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each possible split position, count unique characters in left and right substrings separately. Compare the counts and increment result if they match.

Two-Pass with Hash Maps

⏱️ Time: O(n) Space: O(1)

First pass counts all characters on the right side. Second pass moves through the string, transferring characters from right to left while tracking unique counts efficiently.

Brute Force — Algorithm Steps

Iterate through each valid split position (1 to n-1)
For each position, count distinct chars in left substring
Count distinct chars in right substring
If counts are equal, increment result

Visualization

Tap to expand

Step-by-Step Walkthrough

Split at position i

Divide string into left and right parts

Count unique chars

Count distinct characters in each part

Compare counts

If equal, increment result counter

Code -

solution.c — C

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

int countUnique(char* str, int start, int end) {
    bool seen[26] = {false};
    int count = 0;
    
    for (int i = start; i < end; i++) {
        int index = str[i] - 'a';
        if (!seen[index]) {
            seen[index] = true;
            count++;
        }
    }
    
    return count;
}

int solution(char* s) {
    int n = strlen(s);
    int count = 0;
    
    for (int i = 1; i < n; i++) {
        int leftUnique = countUnique(s, 0, i);
        int rightUnique = countUnique(s, i, n);
        
        if (leftUnique == rightUnique) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n split positions, we scan up to n characters to count distinct letters

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for character frequency tracking

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler