Split a String in Balanced Strings - Practice Coding Problems

Split a String in Balanced Strings - Problem

Imagine you're tasked with organizing a sequence of left and right movements into balanced groups. A balanced string contains an equal number of 'L' (left) and 'R' (right) characters.

Given a balanced string s, your goal is to split it into the maximum number of balanced substrings. Each substring must be balanced on its own, meaning it has equal counts of 'L' and 'R' characters.

Example: For string "RLRRLLRLRL", you could split it as ["RL", "RRLL", "RL", "RL"] to get 4 balanced substrings, which is the maximum possible.

The key insight is to be greedy: whenever you find the first balanced substring, cut it immediately to maximize the total count!

Input & Output

example_1.py — Basic Case

$ Input: s = "RLRRLLRLRL"

› Output: 4

💡 Note: We can split into ["RL", "RRLL", "RL", "RL"] - each part is balanced and we get maximum 4 substrings

example_2.py — Longer Balanced Groups

$ Input: s = "RLLLLRRRLR"

› Output: 3

💡 Note: We can split into ["RLLLLRRR", "L", "R"] - wait, that's wrong. Actually ["RLLLLLRRR"] would be unbalanced. Correct split: ["RL", "LL", "RRR"] - no wait, that's also wrong. Let me recalculate: split as ["RLLLLRRR", "LR"] gives us 2 balanced substrings. Actually: ["RLLL", "LRRR", "LR"] - no. Correct answer: we get splits at positions where counter=0, giving us 3 total balanced substrings.

example_3.py — Minimum Case

$ Input: s = "RL"

› Output: 1

💡 Note: The entire string "RL" is already balanced, so we get 1 balanced substring

Constraints

1 ≤ s.length ≤ 1000
s[i] is either 'L' or 'R'
s is guaranteed to be balanced (equal number of L and R)

Visualization

Tap to expand

Understanding the Visualization

Start with Empty Scale

Begin with counter = 0 (balanced scale)

Add Weights

R adds +1 to right side, L adds +1 to left side (net -1)

Detect Balance

When counter returns to 0, the scale is balanced again

Complete Scale

Count this balanced scale and start a new one immediately

Maximize Output

This greedy approach gives maximum number of complete scales

Key Takeaway

🎯 Key Insight: Cut immediately when balanced (counter = 0) to maximize total output. Waiting longer never increases the final count!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a greedy counter approach in O(n) time. Track a running balance counter: +1 for 'R', -1 for 'L'. Whenever the counter hits zero, we've found a balanced substring - cut it immediately! This greedy strategy guarantees the maximum number of balanced splits.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Splits)	O(2^n)	O(n)	Generate all possible ways to split the string and count valid balanced splits
Greedy Counter (Optimal)	O(n)	O(1)	Use a running counter to greedily split whenever balance is achieved

Brute Force (Try All Splits) — Algorithm Steps

Generate all possible ways to split the string using recursion
For each split configuration, check if all substrings are balanced
A substring is balanced if count of 'L' equals count of 'R'
Track the maximum number of valid splits found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Partitions

Create all possible ways to split 'RLRR' - could be [R|L|R|R], [RL|RR], [R|LRR], etc.

Check Each Partition

For partition [RL|RR]: RL is balanced (1R, 1L), but RR is not balanced (2R, 0L)

Find Valid Partitions

Only partitions where ALL parts are balanced are valid solutions

Return Maximum

Among all valid partitions, return the one with most parts

Code -

solution.c — C

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

bool isBalanced(char* substring) {
    int count = 0;
    for (int i = 0; substring[i]; i++) {
        if (substring[i] == 'R') count++;
        else count--;
    }
    return count == 0;
}

int backtrack(char* s, int index, char splits[][100], int splitCount, int len) {
    if (index == len) {
        for (int i = 0; i < splitCount; i++) {
            if (!isBalanced(splits[i])) {
                return 0;
            }
        }
        return splitCount;
    }
    
    int maxSplits = 0;
    for (int i = index + 1; i <= len; i++) {
        strncpy(splits[splitCount], s + index, i - index);
        splits[splitCount][i - index] = '\0';
        int result = backtrack(s, i, splits, splitCount + 1, len);
        if (result > maxSplits) maxSplits = result;
    }
    
    return maxSplits;
}

int balancedStringSplit(char* s) {
    char splits[100][100];
    return backtrack(s, 0, splits, 0, strlen(s));
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    printf("%d\n", balancedStringSplit(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We try all possible ways to split the string, which is 2^(n-1) possibilities

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth can go up to n levels deep

⚡ Linearithmic Space

58.8K Views

Medium Frequency

~5 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Splits) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler