 GFG App
Open App Browser
Continue

# Generate all binary strings without consecutive 1’s

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` `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;` `}`

## Java

 `// Java program to Generate all binary string without` `// consecutive 1's of size K` `import` `java.util.*;` `import` `java.lang.*;`   `public` `class` `BinaryS {`   `    ``// Array conversion to String--` `    ``public` `static` `String toString(``char``[] a) {` `        ``String string = ``new` `String(a);` `        ``return` `string;` `    ``}`   `    ``static` `void` `generate(``int` `k, ``char``[] ch, ``int` `n) {` `      `  `        ``// Base Condition when we ` `        ``// reached at the end of Array**` `        ``if` `(n == k) {` `          `  `            ``// Printing the Generated String**` `            ``// Return to the previous case*` `            ``System.out.print(toString(ch)+``" "``);` `            ``return``;`   `        ``}` `      `  `        ``// If the first Character is ` `        ``//Zero then adding**` `        ``if` `(ch[n - ``1``] == ``'0'``) {` `            ``ch[n] = ``'0'``;` `            ``generate(k, ch, n + ``1``);` `            ``ch[n] = ``'1'``;` `            ``generate(k, ch, n + ``1``);` `        ``}` `      `  `        ``// If the Character is One ` `        ``// then add Zero to next**` `        ``if` `(ch[n - ``1``] == ``'1'``) {`   `            ``ch[n] = ``'0'``;` `          `  `            ``// Calling Recursively for the ` `            ``// next value of Array` `            ``generate(k, ch, n + ``1``);`   `        ``}` `    ``}`   `    ``static` `void` `fun(``int` `k) {`   `        ``if` `(k <= ``0``) {` `            ``return``;` `        ``}`   `        ``char``[] ch = ``new` `char``[k];` `      `  `        ``// Initializing first character to Zero` `        ``ch[``0``] = ``'0'``;` `      `  `        ``// Generating Strings starting with Zero--` `        ``generate(k, ch, ``1``);`   `        ``// Initialized first Character to one--` `        ``ch[``0``] = ``'1'``;` `        ``generate(k, ch, ``1``);`   `    ``}`   `    ``public` `static` `void` `main(String args[]) {`   `        ``int` `k = ``3``;` `      `  `        ``//Calling function fun with argument k` `        ``fun(k);` `      `  `        ``//This code is Contributed by Praveen Tiwari` `    ``}` `}`

## 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`

## C#

 `// C# program to Generate ` `// all binary string without` `// consecutive 1's of size K` `using` `System;` `class` `GFG {`   `  ``// Array conversion to String--` `  ``static` `string` `toString(``char``[] a) {` `    ``string` `String = ``new` `string``(a);` `    ``return` `String;` `  ``}`   `  ``static` `void` `generate(``int` `k, ``char``[] ch, ``int` `n) {`   `    ``// Base Condition when we ` `    ``// reached at the end of Array**` `    ``if` `(n == k) {`   `      ``// Printing the Generated String**` `      ``// Return to the previous case*` `      ``Console.Write(toString(ch)+``" "``);` `      ``return``;`   `    ``}`   `    ``// If the first Character is ` `    ``//Zero then adding**` `    ``if` `(ch[n - 1] == ``'0'``) {` `      ``ch[n] = ``'0'``;` `      ``generate(k, ch, n + 1);` `      ``ch[n] = ``'1'``;` `      ``generate(k, ch, n + 1);` `    ``}`   `    ``// If the Character is One ` `    ``// then add Zero to next**` `    ``if` `(ch[n - 1] == ``'1'``) {`   `      ``ch[n] = ``'0'``;`   `      ``// Calling Recursively for the ` `      ``// next value of Array` `      ``generate(k, ch, n + 1);`   `    ``}` `  ``}`   `  ``static` `void` `fun(``int` `k)` `  ``{` `    ``if` `(k <= 0)` `    ``{` `      ``return``;` `    ``}` `    ``char``[] ch = ``new` `char``[k];`   `    ``// Initializing first character to Zero` `    ``ch = ``'0'``;`   `    ``// Generating Strings starting with Zero--` `    ``generate(k, ch, 1);`   `    ``// Initialized first Character to one--` `    ``ch = ``'1'``;` `    ``generate(k, ch, 1);`   `  ``}`   `  ``// Driver code` `  ``static` `void` `Main() ` `  ``{` `    ``int` `k = 3;`   `    ``//Calling function fun with argument k` `    ``fun(k);` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07.`

## 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 ` `using` `namespace` `std;`   `void` `All_Binary_Strings(``bool` `arr[],``int` `num,``int` `r)` `{` `    ``if``(r==num)` `    ``{` `        ``for``(``int` `i=0;i

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;`   `class` `GFG {` `    ``static` `void` `All_Binary_Strings(``int` `arr[],``int` `num,``int` `r)` `{` `    ``if``(r == num)` `    ``{` `        ``for``(``int` `i = ``0``; i < num; i++)` `            ``System.out.print(arr[i]);` `            ``System.out.print(``" "``);` `        `  `        ``return``;` `    ``}` `    ``else` `if``(arr[r-``1``] == ``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``);` `    ``}` `}`   `static` `void` `print(``int` `a[],``int` `num)` `{` `    ``a[``0``] = ``0``;` `    ``All_Binary_Strings(a,num,``1``);` `    ``a[``0``] = ``1``;` `    ``All_Binary_Strings(a,num,``1``);` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``int` `n = ``2``;` `    ``int` `a[] = ``new` `int``[n];` `    ``print(a,n);` `}` `}`   `// This code is contributed by shinjanpatra.`

## Python3

 `def` `All_Binary_Strings(arr,num,r):`   `    ``if``(r ``=``=` `num):`   `        ``for` `i ``in` `range``(num):` `            ``print``(arr[i],end``=``"")` `        ``print``(end``=``" "``)` `        ``return` `    `  `    ``elif``(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``)`     `def` `Print``(a,num):` `    ``a[``0``] ``=` `0` `    ``All_Binary_Strings(a,num,``1``)` `    ``a[``0``] ``=` `1` `    ``All_Binary_Strings(a,num,``1``)`     `# driver's code`   `n ``=` `2` `a ``=` `[``False` `for` `i ``in` `range``(n)]` `Print``(a,n)`   `# This code is contributed by shinjanpatra`

## C#

 `// C# program to Generate` `// all binary string without` `using` `System;`   `public` `static` `class` `GFG {`   `    ``public` `static` `void` `All_Binary_Strings(``int``[] arr,` `                                          ``int` `num, ``int` `r)` `    ``{` `        ``if` `(r == num) {` `            ``for` `(``int` `i = 0; i < num; i++) {` `                ``Console.Write(arr[i]);` `            ``}` `            ``Console.Write(``" "``);` `            ``return``;` `        ``}` `        ``else` `if` `(arr[r - 1] == 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);` `        ``}` `    ``}`   `    ``public` `static` `void` `print(``int``[] a, ``ref` `int` `num)` `    ``{` `        ``a = 0;` `        ``All_Binary_Strings(a, num, 1);` `        ``a = 1;` `        ``All_Binary_Strings(a, num, 1);` `    ``}`   `    ``// driver's code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `n = 2;` `        ``int``[] a = ``new` `int``[n];` `        ``print(a, ``ref` `n);` `    ``}` `}`   `// This code is contributed by Aarti_Rathi`

## 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 ` `using` `namespace` `std;`   `void` `All_Binary_Strings(string str,``int` `num)` `{` `    ``int` `len=str.length();` `    ``if``(len==num)` `    ``{` `        ``cout<

## Java

 `import` `java.util.*;`   `public` `class` `GFG {`   `    ``static` `void` `All_Binary_Strings(String str, ``int` `num)` `    ``{` `        ``int` `len = str.length();` `        ``if` `(len == num) {` `            ``System.out.print(str + ``" "``);` `            ``return``;` `        ``}` `        ``else` `if` `(str.charAt(len - ``1``) == ``'1'``)` `            ``All_Binary_Strings(str + ``'0'``, num);` `        ``else` `{` `            ``All_Binary_Strings(str + ``'0'``, num);` `            ``All_Binary_Strings(str + ``'1'``, num);` `        ``}` `    ``}`   `    ``static` `void` `print(``int` `num)` `    ``{` `        ``String word = ``""``;` `        ``word += ``'0'``;` `        ``All_Binary_Strings(word, num);` `        ``word = ``"1"``;` `        ``All_Binary_Strings(word, num);` `    ``}`   `    ``// driver's code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `n = ``4``;` `        ``print(n);` `    ``}` `}`   `// This code is contributed by Karandeep1234`

## Python3

 `def` `All_Binary_Strings(``str``,num):`   `    ``Len` `=` `len``(``str``)` `    ``if``(``Len` `=``=` `num):` `        ``print``(``str``,end ``=` `" "``)` `        ``return`   `    ``elif``(``str``[``Len` `-` `1``]``=``=``'1'``):` `        ``All_Binary_Strings(``str``+``'0'``,num)` `    ``else``:` `        ``All_Binary_Strings(``str``+``'0'``,num)` `        ``All_Binary_Strings(``str``+``'1'``,num)`   `def` `Print``(num):`   `    ``word ``=` `""` `    ``word ``+``=` `'0'` `    ``All_Binary_Strings(word,num)` `    ``word ``=` `'1'` `    ``All_Binary_Strings(word,num)`   `# Driver's code` `n ``=` `4` `Print``(n)`   `# This code is contributed by shinjanpatra.`

## C#

 `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``static` `void` `All_Binary_Strings(String str, ``int` `num)` `  ``{` `    ``int` `len = str.Length;` `    ``if` `(len == num) {` `      ``Console.Write(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);` `    ``}` `  ``}`   `  ``static` `void` `print(``int` `num)` `  ``{` `    ``string` `word = ``""``;` `    ``word += ``'0'``;` `    ``All_Binary_Strings(word, num);` `    ``word = ``"1"``;` `    ``All_Binary_Strings(word, num);` `  ``}`   `  ``// driver's code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int` `n = 4;` `    ``print(n);` `  ``}` `}`   `// This code is contributed by Karandeep1234`

## 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 ` `#include ` `using` `namespace` `std;`   `vector generate_binary_strings(``int` `n) {` `  ``if` `(n == 0) {` `    ``return` `{``""``};` `  ``}` `  ``if` `(n == 1) {` `    ``return` `{``"0"``, ``"1"``};` `  ``}` `  ``vector 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 binary_strings = generate_binary_strings(4);` `  ``for` `(string s : binary_strings) {` `    ``cout << s << ``" "``;` `  ``}` `  ``return` `0;` `}`   `// This code is contributed by Susobhan Akhuli`

## Java

 `// Java code for the above approach ` `import` `java.util.ArrayList;`   `public` `class` `Main {` `  ``public` `static` `ArrayList generateBinaryStrings(``int` `n) {` `    ``if` `(n == ``0``) {` `      ``ArrayList emptyList = ``new` `ArrayList();` `      ``emptyList.add(``""``);` `      ``return` `emptyList;` `    ``}` `    ``if` `(n == ``1``) {` `      ``ArrayList list = ``new` `ArrayList();` `      ``list.add(``"0"``);` `      ``list.add(``"1"``);` `      ``return` `list;` `    ``}` `    ``ArrayList result = ``new` `ArrayList();` `    ``ArrayList prevList = generateBinaryStrings(n - ``1``);` `    ``for` `(String s : prevList) {` `      ``result.add(s + ``"0"``);` `      ``if` `(s.charAt(s.length() - ``1``) != ``'1'``) {` `        ``result.add(s + ``"1"``);` `      ``}` `    ``}` `    ``return` `result;` `  ``}`   `  ``public` `static` `void` `main(String[] args) {` `    ``ArrayList binaryStrings = generateBinaryStrings(``4``);` `    ``for` `(String s : binaryStrings) {` `      ``System.out.print(s + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed adityashatmfh`

## Python3

 `def` `generate_binary_strings(n: ``int``):` `    ``if` `n ``=``=` `0``:` `        ``return` `[""]` `    ``if` `n ``=``=` `1``:` `        ``return` `[``"0"``, ``"1"``]` `    ``result ``=` `[]` `    ``for` `s ``in` `generate_binary_strings(n``-``1``):` `        ``result.append(s ``+` `"0"``)` `        ``if` `s[``-``1``] !``=` `"1"``:` `            ``result.append(s ``+` `"1"``)` `    ``return` `result`   `# Example usage` `arr ``=` `generate_binary_strings(``4``)` `for` `i ``in` `arr:` `      ``print``(i,end``=``' '``)`   `# This code is contributed by Susobhan Akhuli`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Gfg` `{` `  ``static` `List<``string``> GenerateBinaryStrings(``int` `n)` `  ``{` `    ``if` `(n == 0)` `    ``{` `      ``return` `new` `List<``string``>() { ``""` `};` `    ``}`   `    ``if` `(n == 1)` `    ``{` `      ``return` `new` `List<``string``>() { ``"0"``, ``"1"` `};` `    ``}`   `    ``var` `result = ``new` `List<``string``>();` `    ``foreach` `(``string` `s ``in` `GenerateBinaryStrings(n - 1))` `    ``{` `      ``result.Add(s + ``"0"``);`   `      ``if` `(s[s.Length - 1] != ``'1'``)` `      ``{` `        ``result.Add(s + ``"1"``);` `      ``}` `    ``}`   `    ``return` `result;` `  ``}`   `  ``static` `void` `Main(``string``[] args)` `  ``{` `    ``List<``string``> binaryStrings = GenerateBinaryStrings(4);`   `    ``foreach` `(``string` `s ``in` `binaryStrings)` `    ``{` `      ``Console.Write(s + ``" "``);` `    ``}`   `    ``Console.ReadLine();` `  ``}` `}`

## Javascript

 `// Javascript implementation of above approach` `    ``function` `generate_binary_strings(n) {` `        ``if` `(n == 0) {` `              ``return` `[``""``];` `        ``}` `        ``if` `(n == 1) {` `              ``return` `[``"0"``, ``"1"``];` `        ``}` `        ``let result = [];` `        ``var` `temp = generate_binary_strings(n - 1);` `        ``for` `(let i = 0; i < temp.length;i++) {` `            ``let s = temp[i];` `            ``result.push(s + ``"0"``);` `            ``if` `(s[s.length - 1] != ``'1'``) {` `              ``result.push(s + ``"1"``);` `            ``}` `        ``}` `        ``return` `result;` `    ``}`   `    ``// main function` `    ``let binary_strings = generate_binary_strings(4);` `    ``for` `(let i = 0;i

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.

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

My Personal Notes arrow_drop_up