Find All Possible Stable Binary Arrays I - Practice Coding Problems

Find All Possible Stable Binary Arrays I - Problem

You are given 3 positive integers zero, one, and limit.

A binary array arr is called stable if:

The number of occurrences of 0 in arr is exactly zero.
The number of occurrences of 1 in arr is exactly one.
Each subarray of arr with a size greater than limit must contain both 0 and 1.

Return the total number of stable binary arrays. Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: zero = 1, one = 1, limit = 2

› Output: 2

💡 Note: Two valid arrays: [0,1] and [1,0]. Both have exactly 1 zero and 1 one, and no subarray of length > 2 exists.

Example 2 — Larger Limit

$ Input: zero = 1, one = 2, limit = 1

› Output: 1

💡 Note: Only [1,0,1] is valid. Arrays like [1,1,0] would have two consecutive 1s, violating limit=1.

Example 3 — Higher Counts

$ Input: zero = 3, one = 1, limit = 2

› Output: 3

💡 Note: Valid arrays are [0,0,1,0], [0,1,0,0], and [1,0,0,0]. No more than 2 consecutive same digits allowed.

Constraints

1 ≤ zero, one, limit ≤ 200

Visualization

Tap to expand

Understanding the Visualization

Input

Need 1 zero, 1 one, limit=2 consecutive

Build

Generate valid arrangements: [0,1] and [1,0]

Count

Return total number of stable arrays: 2

Key Takeaway

🎯 Key Insight: Use dynamic programming to track state transitions while respecting consecutive digit limits

Asked in

G Google 25 a Amazon 18 f Facebook 15

The key insight is to use dynamic programming with state tracking to count valid arrangements efficiently. Track remaining zeros/ones, last digit placed, and consecutive count to ensure no more than 'limit' consecutive same digits. Best approach uses memoization with Time: O(zero × one × limit), Space: O(zero × one × limit).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Recursion	O(2^(zero+one))	O(zero+one)	Try all possible arrangements recursively and count valid ones
Dynamic Programming with Memoization	O(zero × one × limit)	O(zero × one × limit)	Use recursive DP with memoization to avoid recalculating same states

Brute Force Recursion — Algorithm Steps

Recursively place 0s and 1s
Check if current arrangement violates limit constraint
Count valid complete arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty array, need 2 zeros and 1 one

Branch

Try placing 0 or 1 at each position

Validate

Check if complete array satisfies limit constraint

Code -

solution.c — C

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

#define MOD 1000000007

int isValid(int* arr, int n, int limit) {
    for (int i = 0; i <= n - limit - 1; i++) {
        int hasZero = 0, hasOne = 0;
        for (int j = i; j <= i + limit; j++) {
            if (arr[j] == 0) hasZero = 1;
            else hasOne = 1;
        }
        if (!hasZero || !hasOne) {
            return 0;
        }
    }
    return 1;
}

long long backtrack(int zerosLeft, int onesLeft, int* current, int pos, int limit) {
    if (zerosLeft == 0 && onesLeft == 0) {
        return isValid(current, pos, limit) ? 1 : 0;
    }
    
    long long count = 0;
    if (zerosLeft > 0) {
        current[pos] = 0;
        count += backtrack(zerosLeft - 1, onesLeft, current, pos + 1, limit);
    }
    if (onesLeft > 0) {
        current[pos] = 1;
        count += backtrack(zerosLeft, onesLeft - 1, current, pos + 1, limit);
    }
    return count % MOD;
}

int solution(int zero, int one, int limit) {
    int* current = (int*)malloc((zero + one) * sizeof(int));
    int result = backtrack(zero, one, current, 0, limit);
    free(current);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^(zero+one))

Each position can be 0 or 1, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(zero+one)

Recursion stack depth equals total array length

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~35 min Avg. Time

450 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