Open In App

Generate all binary strings without consecutive 1’s

Last Updated : 30 Jul, 2024
Summarize
Comments
Improve
Suggest changes
Like Article
Like
Share
Report
News Follow
Try it on GfG Practice
redirect icon

Given an integer, K. Generate all binary strings of size k without consecutive 1’s.

Examples: 

Input : K = 3  
Output : 000 , 001 , 010 , 100 , 101 
Input : K  = 4 
Output :0000 0001 0010 0100 0101 1000 1001 1010

Idea behind that is IF string ends with ‘1’ then we put only ‘0’ at the end. IF string ends with ‘0’ then we put both ‘0’ and ‘1’ at the end of string for generating new string.

Below is algorithm  

K : size of string 
First We Generate All string starts with '0'
initialize n = 1 . 
GenerateALLString ( K  , Str , n )
  a. IF n == K 
     PRINT str.
  b. IF previous character is '1' :: str[n-1] == '1'
     put str[n] = '0'
     GenerateAllString ( K , str , n+1 )
  c. IF previous character is '0' :: str[n-1] == '0'
     First We Put zero at end and call function 
      PUT  str[n] = '0'
           GenerateAllString ( K , str , n+1 )  
      PUT  str[n] = '1'
           GenerateAllString ( K , str , n+1 )
Second Generate all binary string starts with '1'
DO THE SAME PROCESS

Below is the recursive implementation: 

C++ 
// C++ program to Generate
// all binary string without
// consecutive 1's of size K
#include <bits/stdc++.h>
using namespace std;

// A utility function generate all string without
// consecutive 1'sof size K
void generateAllStringsUtil(int K, char str[], int n)
{

    // Print binary string without consecutive 1's
    if (n == K) {

        // Terminate binary string
        str[n] = '\0';
        cout << str << " ";
        return;
    }

    // If previous character is '1' then we put
    // only 0 at end of string
    // example str = "01" then new string be "010"
    if (str[n - 1] == '1') {
        str[n] = '0';
        generateAllStringsUtil(K, str, n + 1);
    }

    // If previous character is '0' than we put
    // both '1' and '0' at end of string
    // example str = "00" then
    // new string "001" and "000"
    if (str[n - 1] == '0') {
        str[n] = '0';
        generateAllStringsUtil(K, str, n + 1);
        str[n] = '1';
        generateAllStringsUtil(K, str, n + 1);
    }
}

// Function generate all binary string without
// consecutive 1's
void generateAllStrings(int K)
{
    // Base case
    if (K <= 0)
        return;

    // One by one stores every
    // binary string of length K
    char str[K + 1];

    // Generate all Binary string
    // starts with '0'
    str[0] = '0';
    generateAllStringsUtil(K, str, 1);

    // Generate all Binary string
    // starts with '1'
    str[0] = '1';
    generateAllStringsUtil(K, str, 1);
}

// Driver program to test above function
int main()
{
    int K = 3;
    generateAllStrings(K);
    return 0;
}
Java Python C# JavaScript

Output
000 001 010 100 101

Time complexity: O(2^K) where K is the size of the binary string. This is due to the fact that the algorithm recursively generates all possible binary strings of length K.
Auxiliary space: O(K), since we are using a string array of size K to store the binary string.

This problem is solved by using a recursion tree having two possibilities 0 or 1 just like selecting elements in a subsequence.

So we can also implement above approach using boolean array as well.

C++14 
#include <bits/stdc++.h>
using namespace std;

void All_Binary_Strings(bool arr[],int num,int r)
{
    if(r==num)
    {
        for(int i=0;i<num;i++)
        cout<<arr[i];
        cout<<" ";
        return;
    }
    else if(arr[r-1])
    {
        arr[r]=0;
        All_Binary_Strings(arr,num,r+1);
    }
    else
    {
         arr[r]=0;
        All_Binary_Strings(arr,num,r+1);
         arr[r]=1;
        All_Binary_Strings(arr,num,r+1);
    }
}

void print(bool a[],int& num)
{
    a[0]=0;
    All_Binary_Strings(a,num,1);
    a[0]=1;
    All_Binary_Strings(a,num,1);
}

//driver's code
int main()
{
    int n=2;
    bool a[n];
    print(a,n);
    return 0;
}
Java Python C# JavaScript

Output
00 01 10

Time Complexity: O(2^n),as we can see that we are calling the recursive function two times for every recursion level. Hence, the time complexity is 2^n.
Space Complexity: O(n) since we are using a boolean array of size n.

The above approach can also be solved using string. It does not have any effect on complexity but string handling, printing and operating is easy.

C++14 
#include <bits/stdc++.h>
using namespace std;

void All_Binary_Strings(string str,int num)
{
    int len=str.length();
    if(len==num)
    {
        cout<<str<<" ";
        return;
    }
    else if(str[len-1]=='1')
        All_Binary_Strings(str+'0',num);
    else
    {
        All_Binary_Strings(str+'0',num);
        All_Binary_Strings(str+'1',num);
    }
}

void print(int& num)
{
    string word;
    word.push_back('0');
    All_Binary_Strings(word,num);
    word[0]='1';
    All_Binary_Strings(word,num);
}

//driver's code
int main()
{
    int n=4;
    print(n);
    return 0;
}
Java Python C# JavaScript

Output
0000 0001 0010 0100 0101 1000 1001 1010

Time Complexity: O(2^n)
Auxiliary Space: O(n)

Another easy recursion method to Generate Binary Strings Without Consecutive 1’s.

C++ 
#include <iostream>
#include <vector>
using namespace std;

vector<string> generate_binary_strings(int n) {
  if (n == 0) {
    return {""};
  }
  if (n == 1) {
    return {"0", "1"};
  }
  vector<string> result;
  for (string s : generate_binary_strings(n - 1)) {
    result.push_back(s + "0");
    if (s[s.length() - 1] != '1') {
      result.push_back(s + "1");
    }
  }
  return result;
}

int main() {
  vector<string> binary_strings = generate_binary_strings(4);
  for (string s : binary_strings) {
    cout << s << " ";
  }
  return 0;
}

// This code is contributed by Susobhan Akhuli
Java Python C# JavaScript PHP

Output
0000 0001 0010 0100 0101 1000 1001 1010

Time Complexity: O(2n), where n is the length of the binary strings to be generated.
Auxiliary Space: O(2n) because at any point in time, the function stores all the binary strings generated so far in the result list, and as the number of strings generated is 2n, the space required to store them is also 2n.




Next Article
Find i'th Index character in a binary string obtained after n iterations

N

Nishant Singh
News
Improve
Article Tags :
Practice Tags :

Similar Reads

three90RightbarBannerImg
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox