Count Ways To Build Good Strings - Practice Coding Problems

Count Ways To Build Good Strings - Problem

Dynamic Programming Medium

You're a string architect tasked with building strings using a unique construction process. You start with an empty string and can repeatedly perform one of two operations:

Add zero consecutive '0' characters
Add one consecutive '1' characters

For example, if zero = 2 and one = 3, you could build strings like:

"00" (one operation: add 2 zeros)
"111" (one operation: add 3 ones)
"00111" (two operations: add 2 zeros, then 3 ones)
"11100" (two operations: add 3 ones, then 2 zeros)

A good string is one whose length falls between low and high (inclusive). Your goal is to count how many different good strings can be constructed using this process.

Since the answer can be extremely large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: low = 3, high = 3, zero = 1, one = 1

› Output: 8

💡 Note: We need strings of exactly length 3. With zero=1 and one=1, we can add one '0' or one '1' at each step. All possible strings: "000", "001", "010", "011", "100", "101", "110", "111". Total: 8 strings.

example_2.py — Range Case

$ Input: low = 2, high = 3, zero = 1, one = 2

› Output: 5

💡 Note: With zero=1 (add one '0') and one=2 (add two '1's), we can build: Length 2: "00", "11" (2 strings). Length 3: "000", "011", "110" (3 strings). Total: 2 + 3 = 5 strings.

example_3.py — Large Numbers

$ Input: low = 1, high = 100000, zero = 1, one = 1

› Output: 215447031

💡 Note: This is essentially counting binary strings of length 1 to 100000. For length n, there are 2^n strings. We sum 2^1 + 2^2 + ... + 2^100000 and take modulo 10^9+7, which equals 215447031.

Constraints

1 ≤ low ≤ high ≤ 10⁵
1 ≤ zero, one ≤ high
Answer fits in 32-bit integer after taking modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Start with empty foundation

Begin with length 0 - there's exactly 1 way to have nothing

Add blocks incrementally

For each length i, count ways by adding block of size 'zero' to length (i-zero) or block of size 'one' to length (i-one)

Build up to target length

Continue this process until we've calculated ways for all lengths up to 'high'

Sum the valid range

Add up all the ways for lengths between 'low' and 'high' inclusive

Key Takeaway

🎯 Key Insight: This problem transforms from exponential recursion to linear DP by recognizing that each length can be built by extending shorter valid lengths. The magic happens when we realize dp[i] depends only on dp[i-zero] and dp[i-one]!

Asked in

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

This is a classic dynamic programming problem similar to climbing stairs. The key insight is that dp[i] = dp[i-zero] + dp[i-one], representing the number of ways to build strings of length i. We build the solution incrementally from length 0 to high, then sum all valid lengths between low and high. Time complexity: O(high), Space complexity: O(high).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(high)	O(high)	Build solution incrementally using memoization to avoid repeated calculations

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create DP array where dp[i] = number of ways to build string of length i
Initialize dp[0] = 1 (one way to build empty string)
For each length from 1 to high, calculate dp[i]
dp[i] = dp[i-zero] + dp[i-one] (if those indices are valid)
Sum all dp[i] where low ≤ i ≤ high

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize dp[0] = 1

One way to build empty string

Fill dp array

For each length, add ways from previous valid lengths

Sum valid range

Add up all dp[i] where low ≤ i ≤ high

Return result

Total count modulo 10^9 + 7

Code -

solution.c — C

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

#define MOD 1000000007

int countGoodStrings(int low, int high, int zero, int one) {
    int* dp = (int*)calloc(high + 1, sizeof(int));
    dp[0] = 1; // One way to build empty string
    
    for (int i = 1; i <= high; i++) {
        if (i >= zero) {
            dp[i] = (dp[i] + dp[i - zero]) % MOD;
        }
        if (i >= one) {
            dp[i] = (dp[i] + dp[i - one]) % MOD;
        }
    }
    
    int result = 0;
    for (int i = low; i <= high; i++) {
        result = (result + dp[i]) % MOD;
    }
    
    free(dp);
    return result;
}

int main() {
    int low, one, zero, high;
    scanf("%d %d %d %d", &low, &one, &zero, &high);
    printf("%d\n", countGoodStrings(low, high, zero, one));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(high)

We iterate through each length from 0 to high exactly once

✓ Linear Growth

Space Complexity

O(high)

We need an array of size high+1 to store the number of ways for each length

✓ Linear Space

28.4K Views

Medium-High Frequency

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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler