Split a String in Balanced Strings - Practice Coding Problems

Split a String in Balanced Strings - Problem

Balanced strings are those that have an equal quantity of 'L' and 'R' characters.

Given a balanced string s, split it into some number of substrings such that:

Each substring is balanced.

Return the maximum number of balanced strings you can obtain.

Input & Output

Example 1 — Basic Case

$ Input: s = "RLRRLLRLRL"

› Output: 4

💡 Note: We can split into "RL", "RRLL", "RL", "RL", each substring has equal number of 'R' and 'L' characters. Maximum possible splits = 4.

Example 2 — Minimum Size

$ Input: s = "RLRL"

› Output: 2

💡 Note: We can split into "RL", "RL". Each has 1 'R' and 1 'L', so 2 balanced substrings.

Example 3 — All Together

$ Input: s = "LLLLRRRR"

› Output: 1

💡 Note: The entire string is balanced (4 L's and 4 R's), but any proper substring would be unbalanced. So maximum splits = 1.

Constraints

2 ≤ s.length ≤ 1000
s[i] is either 'L' or 'R'
s is a balanced string

Visualization

Tap to expand

Understanding the Visualization

Input

Balanced string with equal L and R characters

Process

Track balance counter, split when it reaches zero

Output

Maximum number of balanced substrings possible

Key Takeaway

🎯 Key Insight: Greedily split whenever the running balance counter returns to zero

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use a greedy approach with a balance counter. Increment the counter for 'R' and decrement for 'L'. Each time the counter reaches zero, we've found a balanced substring and can make a split. Best approach is greedy counter. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(2ⁿ × n²)	O(n)	Check all possible substrings and find maximum balanced splits
Greedy Counter	O(n)	O(1)	Use a balance counter, split whenever it reaches zero

Brute Force — Algorithm Steps

Generate all possible split positions
For each split, check if all substrings are balanced
Keep track of maximum valid splits

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Splits

Try all possible split positions

Validate

Check if each substring is balanced

Find Maximum

Return the split with most balanced substrings

Code -

solution.c — C

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

int isBalanced(const char* substr, int len) {
    int count = 0;
    for (int i = 0; i < len; i++) {
        if (substr[i] == 'R') {
            count++;
        } else {
            count--;
        }
    }
    return count == 0;
}

int backtrack(const char* s, int start, int splits, int len) {
    if (start == len) {
        return splits;
    }
    
    int maxSplits = 0;
    for (int end = start + 1; end <= len; end++) {
        if (isBalanced(s + start, end - start)) {
            int result = backtrack(s, end, splits + 1, len);
            if (result > maxSplits) {
                maxSplits = result;
            }
        }
    }
    
    return maxSplits;
}

int solution(const char* s) {
    return backtrack(s, 0, 0, strlen(s));
}

int main() {
    char s[1001];
    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(2ⁿ × n²)

2^n possible splits, each requiring O(n²) time to validate all substrings

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth for generating splits

⚡ Linearithmic Space

113.6K Views

Medium Frequency

~8 min Avg. Time

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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler