Count Binary Substrings

Count Binary Substrings - Problem

Given a binary string s, return the number of non-empty substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.

Substrings that occur multiple times are counted the number of times they occur.

Example: In string "00110011", valid substrings include "01", "10", "0011", "1100", etc.

Input & Output

Example 1 — Basic Pattern

$ Input: s = "00110011"

› Output: 6

💡 Note: Valid substrings: "01" (at positions 1-2 and 5-6), "10" (at positions 2-3 and 4-5), "0011" (at positions 0-3), "1100" (at positions 2-5). Total = 6 substrings.

Example 2 — Alternating Pattern

$ Input: s = "10101"

› Output: 4

💡 Note: Valid substrings: "01" (at positions 1-2 and 3-4), "10" (at positions 0-1 and 2-3). Each pair of adjacent different characters forms exactly one valid substring.

Example 3 — Single Group

$ Input: s = "1111"

› Output: 0

💡 Note: No valid substrings possible since all characters are the same. We need both 0s and 1s to form valid substrings.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '0' or '1'

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 M Microsoft 22

The key insight is that valid substrings can only be formed at boundaries between consecutive groups of 0s and 1s. For each adjacent pair of groups, the number of valid substrings equals the minimum of their lengths. The optimal single-pass approach tracks previous and current group sizes, calculating results on-the-fly. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

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

For each starting position, expand substring and check if it has equal 0s and 1s with consecutive grouping.

Group Counting with Two Pointers

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

First pass counts the length of each consecutive group of 0s or 1s. Second pass calculates how many valid substrings can be formed between each pair of adjacent groups.

Single Pass Optimized

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

Track previous and current group lengths while iterating. When we encounter a character change, we know min(prev_group, curr_group) valid substrings can be formed.

Brute Force — Algorithm Steps

Step 1: Generate all possible substrings
Step 2: For each substring, verify equal counts and consecutive grouping
Step 3: Count valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all O(n²) possible substrings

Validate

Check each substring for equal 0s/1s and consecutive grouping

Count

Sum up all valid substrings

Code -

solution.c — C

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

bool isValid(const char* s, int len) {
    if (len % 2 != 0) {
        return false;
    }
    
    int zeros = 0, ones = 0;
    for (int i = 0; i < len; i++) {
        if (s[i] == '0') zeros++;
        else ones++;
    }
    
    if (zeros != ones) {
        return false;
    }
    
    char prev = s[0];
    int groups = 1;
    for (int i = 1; i < len; i++) {
        if (s[i] != prev) {
            groups++;
            prev = s[i];
        }
    }
    
    return groups == 2;
}

int solution(const char* s) {
    int count = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (isValid(s + i, j - i)) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char s[10001];
    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³)

Three nested loops: O(n²) substrings × O(n) validation each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

89.5K Views

Medium Frequency

~15 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