Number of Good Binary Strings - Practice Coding Problems

Number of Good Binary Strings - Problem

Dynamic Programming Medium

Binary String Validation Challenge

You're given four parameters: minLength, maxLength, oneGroup, and zeroGroup. Your task is to count how many "good" binary strings exist that satisfy specific block size requirements.

What makes a binary string "good"?
1. Its length is between minLength and maxLength (inclusive)
2. Every consecutive block of 1's has a length that's a multiple of oneGroup
3. Every consecutive block of 0's has a length that's a multiple of zeroGroup

Example: In string "00110111100":
• Blocks of 1's have sizes [2, 4]
• Blocks of 0's have sizes [2, 1, 2]

Return the count modulo 10⁹ + 7. Note that 0 is considered a multiple of all numbers, so empty blocks are always valid.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Valid strings are "00" (length 2) and "111" (length 3). "00" has one block of 0s with size 2 (multiple of 2). "111" has one block of 1s with size 3 (multiple of 1). Other strings like "01", "10", "11" have invalid block sizes.

example_2.py — Multiple Valid Strings

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

› Output: 1

💡 Note: Only "1111" is valid. It has one block of 1s with size 4 (multiple of 4). Strings with 0s would need blocks of size 3, but we need exactly length 4, so mixed strings can't work.

example_3.py — Edge Case

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

› Output: 2

💡 Note: Both "0" and "1" are valid. Each has a single block of size 1, which is a multiple of both group requirements.

Constraints

1 ≤ minLength ≤ maxLength ≤ 10⁵
1 ≤ oneGroup, zeroGroup ≤ maxLength
Result fits in 32-bit integer after modulo operation

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with no chain - this is our base case

Add First Segment

Add either 2 blue beads (00) or 3 red beads (111)

Extend Chains

From chains ending in blue, we can only add red segments; from chains ending in red, we can only add blue segments

Count Valid Lengths

Sum up all chains that fall within our desired length range

Key Takeaway

🎯 Key Insight: Instead of generating all possible strings, we build valid ones incrementally by tracking the ending character and length, ensuring we only add blocks of the correct sizes.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses dynamic programming to count valid binary strings by building them incrementally. We track states based on string length and the ending character (0 or 1), then extend valid strings by adding blocks of consecutive characters with sizes that are multiples of the required group sizes. This avoids the exponential time complexity of generating all possible strings and achieves O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(maxLength × (maxLength/oneGroup + maxLength/zeroGroup))	O(maxLength)	Build valid strings incrementally using state-based dynamic programming

Dynamic Programming (Optimal) — Algorithm Steps

Define DP states: dp[length][lastChar] = number of valid strings of given length ending with lastChar
Initialize base case: empty string is valid
For each length, try adding valid blocks of 0s and 1s
A block is valid if its size is a multiple of the corresponding group size
Sum all valid strings with lengths in [minLength, maxLength]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Case

Start with empty string as valid state

Add Valid Blocks

Extend strings by adding blocks of valid sizes

Track Ending Character

Maintain state based on last character (0 or 1)

Sum Valid Lengths

Count all strings within the required length range

Code -

solution.c — C

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

#define MOD 1000000007

int goodBinaryStrings(int minLength, int maxLength, int oneGroup, int zeroGroup) {
    // dp[i][j] = number of valid strings of length i ending with character j
    long long dp[maxLength + 1][2];
    
    // Initialize
    for (int i = 0; i <= maxLength; i++) {
        dp[i][0] = dp[i][1] = 0;
    }
    
    // Base case
    dp[0][0] = dp[0][1] = 1;
    
    for (int length = 1; length <= maxLength; length++) {
        // Try adding blocks of 0s
        for (int blockSize = zeroGroup; blockSize <= length; blockSize += zeroGroup) {
            int prevLength = length - blockSize;
            if (prevLength == 0) {
                dp[length][0] = (dp[length][0] + 1) % MOD;
            } else {
                dp[length][0] = (dp[length][0] + dp[prevLength][1]) % MOD;
            }
        }
        
        // Try adding blocks of 1s
        for (int blockSize = oneGroup; blockSize <= length; blockSize += oneGroup) {
            int prevLength = length - blockSize;
            if (prevLength == 0) {
                dp[length][1] = (dp[length][1] + 1) % MOD;
            } else {
                dp[length][1] = (dp[length][1] + dp[prevLength][0]) % MOD;
            }
        }
    }
    
    // Sum all valid lengths
    long long result = 0;
    for (int length = minLength; length <= maxLength; length++) {
        result = (result + dp[length][0] + dp[length][1]) % MOD;
    }
    
    return (int) result;
}

Time & Space Complexity

Time Complexity

⏱️

O(maxLength × (maxLength/oneGroup + maxLength/zeroGroup))

For each position, we try all valid block sizes for both 0s and 1s

✓ Linear Growth

Space Complexity

O(maxLength)

DP array to store intermediate results for each length and ending character

⚡ Linearithmic Space

52.8K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler