Find the Longest Balanced Substring of a Binary String

Find the Longest Balanced Substring of a Binary String - Problem

String Easy

You are given a binary string s consisting only of '0's and '1's.

A substring of s is considered balanced if:

All zeroes appear before all ones
The number of zeroes equals the number of ones

For example, "0011" is balanced (2 zeros, 2 ones, zeros first), but "0101" is not (zeros and ones are mixed).

Note: The empty substring is considered balanced.

Goal: Return the length of the longest balanced substring.

Example: In s = "01000111", the longest balanced substring is "000111" with length 6.

Input & Output

example_1.py — Basic Case

$ Input: s = "01000111"

› Output: 6

💡 Note: The longest balanced substring is "000111" (positions 2-7). It has 3 zeros followed by 3 ones, making it perfectly balanced with length 6.

example_2.py — Mixed Pattern

$ Input: s = "00111"

› Output: 4

💡 Note: The longest balanced substring is "0011" (positions 0-3). We have 2 zeros followed by 2 ones, giving us length 4. The remaining "1" cannot form a balanced substring.

example_3.py — No Balance Possible

$ Input: s = "111"

› Output: 0

💡 Note: There are no zeros in the string, so no balanced substring is possible. The only balanced substring is the empty string with length 0.

Constraints

1 ≤ s.length ≤ 50
s[i] is either '0' or '1'
The string consists only of binary characters

Visualization

Tap to expand

Understanding the Visualization

Count Leaders

Count consecutive leaders (0s) that are available for partnership

Match Followers

As followers (1s) arrive, pair them with available leaders

Record Formation

When we have a perfect match, record the formation size

Reset on Disruption

If a new leader arrives after followers, start a new formation

Key Takeaway

🎯 Key Insight: Use a single pass with smart counter management - track available leaders and match them with followers, resetting when the dance formation pattern breaks.

Asked in

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

The optimal solution uses a two-pointer approach with smart counter management. As we scan through the string, we count zeros and ones, resetting when the pattern breaks (seeing '0' after '1'). When we encounter '1's, we check if we have enough preceding '0's to form a balanced substring. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's balanced
Two Pointers (Single Pass)	O(n)	O(1)	Use two pointers to track valid balanced substrings in a single pass

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, check if it's balanced
Count zeros and ones, ensure zeros come before ones
Track the maximum length of balanced substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Use nested loops to generate all possible substrings

Check Balance

For each substring, verify it has equal 0s and 1s with 0s first

Track Maximum

Keep track of the longest balanced substring found

Code -

solution.c — C

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

bool isBalanced(const char* s, int start, int end) {
    if (start > end) return true;
    
    int zeros = 0, ones = 0;
    bool seenOne = false;
    
    for (int i = start; i <= end; i++) {
        if (s[i] == '0') {
            if (seenOne) return false;
            zeros++;
        } else {
            seenOne = true;
            ones++;
        }
    }
    
    return zeros == ones;
}

int findTheLongestBalancedSubstring(const char* s) {
    int n = strlen(s);
    int maxLength = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isBalanced(s, i, j)) {
                int length = j - i + 1;
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    printf("%d\n", findTheLongestBalancedSubstring(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts and maximum length

✓ Linear Space

28.5K Views

Medium Frequency

~15 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 (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler