Generate Binary Strings Without Adjacent Zeros

Generate Binary Strings Without Adjacent Zeros - Problem

You are given a positive integer n. A binary string x is valid if all substrings of x of length 2 contain at least one "1".

Return all valid strings with length n, in any order.

In other words, no two consecutive zeros ("00") are allowed in any valid binary string.

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: ["010","011","101","110","111"]

💡 Note: All valid 3-length binary strings without consecutive zeros. Note that "000", "001", and "100" are invalid because they contain "00".

Example 2 — Minimum Size

$ Input: n = 1

› Output: ["0","1"]

💡 Note: For length 1, both "0" and "1" are valid since there are no substrings of length 2 to check.

Example 3 — Small Case

$ Input: n = 2

› Output: ["01","10","11"]

💡 Note: For length 2, "00" is invalid (contains consecutive zeros), but "01", "10", and "11" are all valid.

Constraints

1 ≤ n ≤ 20

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 Apple 12

The key insight is recognizing that valid binary strings without consecutive zeros follow the Fibonacci sequence pattern. The optimal approach uses backtracking to generate only valid strings by enforcing the constraint that after placing '0', the next character must be '1'. Time: O(φⁿ), Space: O(φⁿ) where φ≈1.618 is the golden ratio.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Memoization

⏱️ Time: N/A Space: N/A

Backtracking

⏱️ Time: O(φⁿ) Space: O(n × φⁿ)

Use recursive backtracking to build strings one character at a time. When we place a '0', we must place a '1' next to avoid consecutive zeros. This approach only generates valid strings.

Brute Force Generation

⏱️ Time: O(n × 2ⁿ) Space: O(n × 2ⁿ)

Generate all 2^n possible binary strings of length n, then check each string to see if it contains consecutive zeros. Only keep strings that pass the validation.

Dynamic Programming with Fibonacci Pattern

⏱️ Time: O(φⁿ) Space: O(φⁿ)

Recognize that the number of valid binary strings follows Fibonacci sequence. Use dynamic programming to first count valid strings, then generate them systematically by tracking string endings.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static char results[10000][32];
static int resultCount = 0;
static char current[32];

void backtrack(int pos, int n) {
    if (pos == n) {
        current[pos] = '\0';
        strcpy(results[resultCount], current);
        resultCount++;
        return;
    }
    
    // Try '1' - always valid
    current[pos] = '1';
    backtrack(pos + 1, n);
    
    // Try '0' - only if previous char is not '0'
    if (pos == 0 || current[pos - 1] != '0') {
        current[pos] = '0';
        backtrack(pos + 1, n);
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    resultCount = 0;
    backtrack(0, n);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", results[i]);
        if (i < resultCount - 1) {
            printf(",");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

342 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