Generate Binary Strings Without Adjacent Zeros

Generate Binary Strings Without Adjacent Zeros - Problem

Generate Valid Binary Strings

You are given a positive integer n. Your task is to generate all possible valid binary strings of length n.

A binary string is considered valid if it contains no adjacent zeros - that is, no substring "00" should appear anywhere in the string. In other words, every substring of length 2 must contain at least one "1".

Goal: Return all valid binary strings of length n in any order.

Example: For n=3, valid strings include "101", "110", "111" but not "100" (contains "00").

Input & Output

example_1.py — Python

$ Input: n = 3

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

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

example_2.py — Python

$ Input: n = 1

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

💡 Note: For length 1, both "0" and "1" are valid since there are no adjacent characters to check.

example_3.py — Python

$ Input: n = 2

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

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

Constraints

1 ≤ n ≤ 18
The answer will contain at most 2¹⁸ strings
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with no switches set, can choose any state for first switch

Apply Rule

For each subsequent switch, check the previous switch state

Make Valid Choices

If previous is OFF, current must be ON. If previous is ON, current can be either

Complete Path

Continue until all n switches are configured

Key Takeaway

🎯 Key Insight: Use backtracking to make smart choices - when the previous character is '0', we have no choice but to place '1'. This constraint significantly reduces the search space and leads to the Fibonacci sequence pattern in the number of valid strings.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 15

The optimal approach uses backtracking to generate valid binary strings incrementally. The key insight is that if the previous character is '0', we must choose '1' for the current position. If the previous character is '1', we can choose either '0' or '1'. This generates exactly the valid strings without waste, achieving O(φⁿ) time complexity where φ is the golden ratio.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(φ^n)	O(n)	Build valid strings character by character using backtracking

Backtracking (Optimal) — Algorithm Steps

Start with an empty string and recursively build character by character
At each position, check the previous character
If previous is '0', current must be '1' (forced choice)
If previous is '1', current can be either '0' or '1' (both choices)
When string reaches length n, add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Empty

Begin with empty string, can choose 0 or 1

Smart Choices

If last char is 0, must choose 1. If last char is 1, can choose 0 or 1

Build Tree

Recursively build all valid paths in the decision tree

Code -

solution.c — C

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

char** result;
int resultSize;
int resultCapacity;

void backtrack(char* currentString, int n) {
    // Base case: if we've built a string of length n
    if (strlen(currentString) == n) {
        if (resultSize >= resultCapacity) {
            resultCapacity *= 2;
            result = (char**)realloc(result, resultCapacity * sizeof(char*));
        }
        result[resultSize] = (char*)malloc((n + 1) * sizeof(char));
        strcpy(result[resultSize], currentString);
        resultSize++;
        return;
    }
    
    int len = strlen(currentString);
    char* newString0 = (char*)malloc((len + 2) * sizeof(char));
    char* newString1 = (char*)malloc((len + 2) * sizeof(char));
    
    // If this is the first character or previous char is '1',
    // we can choose either '0' or '1'
    if (len == 0 || currentString[len - 1] == '1') {
        strcpy(newString0, currentString);
        strcat(newString0, "0");
        backtrack(newString0, n);
        
        strcpy(newString1, currentString);
        strcat(newString1, "1");
        backtrack(newString1, n);
    } else {
        // If previous char is '0', we can only choose '1'
        strcpy(newString1, currentString);
        strcat(newString1, "1");
        backtrack(newString1, n);
    }
    
    free(newString0);
    free(newString1);
}

char** validStrings(int n, int* returnSize) {
    resultCapacity = 100;
    result = (char**)malloc(resultCapacity * sizeof(char*));
    resultSize = 0;
    
    backtrack("", n);
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(φ^n)

φ ≈ 1.618 (golden ratio). Each valid string corresponds to Fibonacci sequence

✓ Linear Growth

Space Complexity

O(n)

Recursion depth is n, plus space for storing result strings

⚡ Linearithmic Space

23.8K Views

Medium 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

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler