Count Binary Substrings - Practice Coding Problems

Count Binary Substrings - Problem

Given a binary string s, find all valid substrings that satisfy these conditions:

Have an equal number of 0's and 1's
All 0's are grouped together consecutively
All 1's are grouped together consecutively

Return the total count of such substrings. Note that substrings appearing multiple times should be counted each time they occur.

Example: In "00110", valid substrings are "0011" and "01" (appears twice), giving us a total count of 3.

Input & Output

example_1.py — Basic Case

$ Input: s = "00110"

› Output: 3

💡 Note: Valid substrings are: "0011" (1 occurrence), "01" (2 occurrences at positions 1-2 and 2-3). Total = 3.

example_2.py — Alternating Pattern

$ Input: s = "10101"

› Output: 4

💡 Note: Valid substrings are: "10" (appears 2 times), "01" (appears 2 times). Each has equal 0s and 1s with proper grouping.

example_3.py — Single Character

$ Input: s = "1"

› Output: 0

💡 Note: No valid substrings possible since we need at least one 0 and one 1 to form a valid substring.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Group Recognition

Identify consecutive runs: '00110' becomes groups [2×0, 2×1, 1×0]

Bridge Building

Between adjacent groups, we can build min(group1, group2) bridges

Count Bridges

Each bridge represents a valid substring: min(2,2)=2 plus min(2,1)=1

Final Count

Sum all bridges: 2 + 1 = 3 valid substrings

Key Takeaway

🎯 Key Insight: Between any two adjacent groups of different characters, the number of valid substrings equals the minimum of their sizes - this transforms a cubic brute force into a linear solution!

Asked in

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

The optimal solution uses a group counting approach in O(n) time. Instead of checking all substrings, we count consecutive groups of 0s and 1s. Between any two adjacent different groups, the number of valid substrings equals the minimum of the two group sizes. This insight transforms an O(n³) brute force into an elegant O(n) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Group Counting)	O(n)	O(1)	Count consecutive groups and calculate valid substrings between adjacent groups
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it's valid

Two Pointers (Group Counting) — Algorithm Steps

Count consecutive characters in each group
For each pair of adjacent different groups
Calculate min(group1_size, group2_size)
This gives the number of valid substrings between these groups
Sum all such counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Groups

Find consecutive runs of 0s and 1s

Count Group Sizes

Track the size of each consecutive group

Calculate Between Groups

For adjacent groups, min(size1, size2) gives valid substrings

Sum Results

Add up all valid substring counts

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int countBinarySubstrings(char* s) {
    int result = 0;
    int prevCount = 0;
    int currCount = 1;
    int len = strlen(s);
    
    for (int i = 1; i < len; i++) {
        if (s[i] == s[i-1]) {
            currCount++;
        } else {
            // New group started
            result += min(prevCount, currCount);
            prevCount = currCount;
            currCount = 1;
        }
    }
    
    // Don't forget the last pair
    result += min(prevCount, currCount);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count groups and calculate results

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current and previous group counts

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

845 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

Two Pointers (Group Counting) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler