Number of Good Binary Strings - Practice Coding Problems

Number of Good Binary Strings - Problem

Dynamic Programming Medium

You are given four integers minLength, maxLength, oneGroup and zeroGroup.

A binary string is good if it satisfies the following conditions:

The length of the string is in the range [minLength, maxLength].
The size of each block of consecutive 1's is a multiple of oneGroup.
The size of each block of consecutive 0's is a multiple of zeroGroup.

For example, in a binary string 00110111100, sizes of each block of consecutive ones are [2,4] and sizes of each block of consecutive zeros are [2,1,2].

Return the number of good binary strings. Since the answer may be too large, return it modulo 10⁹ + 7.

Note that 0 is considered a multiple of all numbers.

Input & Output

Example 1 — Basic Case

$ Input: minLength = 4, maxLength = 4, oneGroup = 4, zeroGroup = 3

› Output: 2

💡 Note: Valid strings of length 4: '0000' (one block of 0s with size 4, but 4 % 3 ≠ 0, invalid) and '1111' (one block of 1s with size 4, 4 % 4 = 0, valid). Actually, let's recalculate: '0000' has block size 4, 4 % 3 ≠ 0 (invalid). '1111' has block size 4, 4 % 4 = 0 (valid). Other valid strings would need blocks of size 3 for 0s and size 4 for 1s.

Example 2 — Multiple Valid Strings

$ Input: minLength = 2, maxLength = 3, oneGroup = 2, zeroGroup = 1

› Output: 8

💡 Note: For zeroGroup=1, any block of 0s is valid. For oneGroup=2, blocks of 1s must have even size. Valid strings include: '00', '11', '000', '011', '101', '110', etc.

Example 3 — No Valid Strings

$ Input: minLength = 1, maxLength = 1, oneGroup = 2, zeroGroup = 2

› Output: 0

💡 Note: Length 1 strings are '0' or '1'. '0' has block size 1, but 1 % 2 ≠ 0. '1' has block size 1, but 1 % 2 ≠ 0. No valid strings exist.

Constraints

1 ≤ minLength ≤ maxLength ≤ 10⁵
1 ≤ oneGroup, zeroGroup ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Input

Length range [minLength, maxLength] and group constraints

Process

Check consecutive block sizes against group requirements

Output

Count of valid binary strings

Key Takeaway

🎯 Key Insight: Use DP to track string building states rather than generating all possible strings

Asked in

f Meta 15 G Google 12 a Amazon 8

The key insight is to use dynamic programming to track valid string building states. We maintain dp[length][lastChar][blockSize] to count valid strings. The optimal DP approach avoids exponential enumeration. Time: O(n × max(oneGroup, zeroGroup)), Space: O(n × max(oneGroup, zeroGroup))

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(2ⁿ × n)	O(n)	Generate all possible binary strings and check validity
Dynamic Programming	O(n × max(oneGroup, zeroGroup))	O(n × max(oneGroup, zeroGroup))	Build valid strings incrementally using state transitions

Brute Force Recursion — Algorithm Steps

Generate all binary strings of valid lengths
For each string, identify consecutive blocks
Check if all blocks have valid sizes

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all binary strings of valid lengths

Validate

Check block constraints for each string

Count

Sum up all valid strings

Code -

solution.c — C

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

#define MOD 1000000007

int isValid(char* s, int oneGroup, int zeroGroup) {
    int len = strlen(s);
    if (len == 0) return 1;
    
    char currentChar = s[0];
    int currentCount = 1;
    
    for (int i = 1; i < len; i++) {
        if (s[i] == currentChar) {
            currentCount++;
        } else {
            if (currentChar == '1' && currentCount % oneGroup != 0) return 0;
            if (currentChar == '0' && currentCount % zeroGroup != 0) return 0;
            currentChar = s[i];
            currentCount = 1;
        }
    }
    
    if (currentChar == '1' && currentCount % oneGroup != 0) return 0;
    if (currentChar == '0' && currentCount % zeroGroup != 0) return 0;
    return 1;
}

long long generate(int length, char* current, int depth, int oneGroup, int zeroGroup) {
    if (depth == length) {
        current[depth] = '\0';
        return isValid(current, oneGroup, zeroGroup) ? 1 : 0;
    }
    
    long long count = 0;
    current[depth] = '0';
    count += generate(length, current, depth + 1, oneGroup, zeroGroup);
    current[depth] = '1';
    count += generate(length, current, depth + 1, oneGroup, zeroGroup);
    return count % MOD;
}

int solution(int minLength, int maxLength, int oneGroup, int zeroGroup) {
    long long result = 0;
    char* current = malloc(maxLength + 1);
    
    for (int length = minLength; length <= maxLength; length++) {
        result = (result + generate(length, current, 0, oneGroup, zeroGroup)) % MOD;
    }
    
    free(current);
    return result;
}

int main() {
    int minLength, maxLength, oneGroup, zeroGroup;
    scanf("%d", &minLength);
    scanf("%d", &maxLength);
    scanf("%d", &oneGroup);
    scanf("%d", &zeroGroup);
    printf("%d\n", solution(minLength, maxLength, oneGroup, zeroGroup));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

Generate 2^n strings for each length n, then O(n) to validate each

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n for string length

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 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 Recursion — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler