# Generate all binary strings without consecutive 1’s

Given a integer K. Task is Print All binary string of size K (Given number).

Examples:

```Input : K = 3
Output : 000 , 001 , 010 , 100 , 101

Input : K  = 4
Output :0000 0001 0010 0100 0101 1000 1001 1010
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 recursive implementation.

## C++

 `// C++ program to Generate all binary string without ` `// consecutive 1's of size K ` `#include ` `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]; ` ` `  `    ``// Generate all Binary string starts with '0' ` `    ``str = ``'0'` `; ` `    ``generateAllStringsUtil ( K , str , 1 ) ; ` ` `  `    ``// Generate all Binary string starts with '1' ` `    ``str = ``'1'` `; ` `    ``generateAllStringsUtil ( K , str , 1 ); ` `} ` ` `  `// Driver program to test above function ` `int` `main() ` `{ ` `    ``int` `K = 3; ` `    ``generateAllStrings (K) ; ` `    ``return` `0; ` `} `

## Python3

 `# Python3 program to Generate all binary string  ` `# without consecutive 1's of size K ` ` `  `# A utility function generate all string without ` `# consecutive 1'sof size K ` `def` `generateAllStringsUtil(K, ``str``, n): ` `     `  `    ``# print binary string without consecutive 1's ` `    ``if` `(n ``=``=` `K): ` `         `  `        ``# terminate binary string ` `        ``print``(``*``str``[:n], sep ``=` `"``", end = "` `") ` `        ``return` `     `  `    ``# if previous character is '1' then we put ` `    ``# only 0 at end of string ` `    ``# example str = "01" then new string be "000" ` `    ``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 ` `def` `generateAllStrings(K): ` `     `  `    ``# Base case ` `    ``if` `(K <``=` `0``): ` `        ``return` `     `  `    ``# One by one stores every binary string of length K ` `    ``str` `=` `[``0``] ``*` `K ` `     `  `    ``# 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 code ` `K ``=` `3` `generateAllStrings (K)  ` ` `  `# This code is contributed by SHUBHAMSINGH10 `

Output:

``` 000 001 010 100 101
```

This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

6

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.