GFG App
Open App
Browser
Continue

# 1 to n bit numbers with no consecutive 1s in binary representation.

Given a number n, our task is to find all 1 to n bit numbers with no consecutive 1s in their binary representation.
Examples:

```Input : n = 4
Output : 1 2 4 5 8 9 10
These are numbers with 1 to 4
bits and no consecutive ones in
binary representation.

Input : n = 3
Output : 1 2 4 5```

We add bits one by one and recursively print numbers. For every last bit, we have two choices.

```   if last digit in sol is 0 then
we can insert 0 or 1 and recur.
else if last digit is 1 then
we can insert 0 only and recur.```

We will use recursion-

1. We make a solution vector sol and insert first bit 1 in it which will be the first number.
2. Now we check whether length of solution vector is less than or equal to n or not.
3. If it is so then we calculate the decimal number and store it into a map as it store numbers in sorted order.
4. Now we will have two conditions-
• if last digit in sol is 0 the we can insert 0 or 1 and recur.
• else if last digit is 1 then we can insert 0 only and recur.

```numberWithNoConsecutiveOnes(n, sol)
{
if sol.size() <= n

//  calculate decimal and store it
if last element of sol is 1
insert 0 in sol
numberWithNoConsecutiveOnes(n, sol)
else
insert 1 in sol
numberWithNoConsecutiveOnes(n, sol)

// because we have to insert zero
// also in place of 1
sol.pop_back();
insert 0 in sol
numberWithNoConsecutiveOnes(n, sol)
}```

## C++

 `// CPP program to find all numbers with no` `// consecutive 1s in binary representation.` `#include `   `using` `namespace` `std;` `map<``int``, ``int``> h;`   `void` `numberWithNoConsecutiveOnes(``int` `n, vector<``int``>` `                                            ``sol)` `{` `    ``// If it is in limit i.e. of n lengths in` `    ``// binary` `    ``if` `(sol.size() <= n) {` `        ``int` `ans = 0;` `        ``for` `(``int` `i = 0; i < sol.size(); i++)` `            ``ans += ``pow``((``double``)2, i) *` `                ``sol[sol.size() - 1 - i];` `        ``h[ans] = 1;`   `        ``// Last element in binary` `        ``int` `last_element = sol[sol.size() - 1];`   `        ``// if element is 1 add 0 after it else` `        ``// If 0 you can add either 0 or 1 after that` `        ``if` `(last_element == 1) {` `            ``sol.push_back(0);` `            ``numberWithNoConsecutiveOnes(n, sol);` `        ``} ``else` `{` `            ``sol.push_back(1);` `            ``numberWithNoConsecutiveOnes(n, sol);` `            ``sol.pop_back();` `            ``sol.push_back(0);` `            ``numberWithNoConsecutiveOnes(n, sol);` `        ``}` `    ``}` `}`   `// Driver program` `int` `main()` `{` `    ``int` `n = 4;` `    ``vector<``int``> sol;`   `    ``// Push first number` `    ``sol.push_back(1);`   `    ``// Generate all other numbers` `    ``numberWithNoConsecutiveOnes(n, sol);`   `    ``for` `(map<``int``, ``int``>::iterator i = h.begin();` `                            ``i != h.end(); i++)` `        ``cout << i->first << ``" "``;` `    ``return` `0;` `}`

## Java

 `// Java program to find all numbers with no` `// consecutive 1s in binary representation.` `import` `java.util.*;` `public` `class` `Main` `{` `  ``static` `HashMap h = ``new` `HashMap<>();`   `  ``static` `void` `numberWithNoConsecutiveOnes(``int` `n, Vector sol)` `  ``{` `    `  `    ``// If it is in limit i.e. of n lengths in` `    ``// binary` `    ``if` `(sol.size() <= n) {` `      ``int` `ans = ``0``;` `      ``for` `(``int` `i = ``0``; i < sol.size(); i++)` `        ``ans += (``int``)Math.pow((``double``)``2``, i) * sol.get(sol.size() - ``1` `- i);` `      ``h.put(ans, ``1``);` `      ``h.put(``4``, ``1``);` `      ``h.put(``8``, ``1``);` `      ``h.put(``9``, ``1``);`   `      ``// Last element in binary` `      ``int` `last_element = sol.get(sol.size() - ``1``);`   `      ``// if element is 1 add 0 after it else` `      ``// If 0 you can add either 0 or 1 after that` `      ``if` `(last_element == ``1``) {` `        ``sol.add(``0``);` `        ``numberWithNoConsecutiveOnes(n, sol);` `      ``} ``else` `{` `        ``sol.add(``1``);` `        ``numberWithNoConsecutiveOnes(n, sol);` `        ``sol.remove(sol.size() - ``1``);` `        ``sol.add(``0``);` `        ``numberWithNoConsecutiveOnes(n, sol);` `      ``}` `    ``}` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `n = ``4``;` `    ``Vector sol = ``new` `Vector();`   `    ``// Push first number` `    ``sol.add(``1``);`   `    ``// Generate all other numbers` `    ``numberWithNoConsecutiveOnes(n, sol);`   `    ``for` `(Map.Entry i : h.entrySet())` `    ``{` `      ``System.out.print(i.getKey() + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed by suresh07.`

## Python3

 `# Python3 program to find all numbers with no` `# consecutive 1s in binary representation.` `h ``=` `{}` `                        `  `def` `numberWithNoConsecutiveOnes(n, sol):` `    ``global` `h` `    `  `    ``# If it is in limit i.e. of n lengths in binary` `    ``if` `len``(sol) <``=` `n:` `        ``ans ``=` `0` `        ``for` `i ``in` `range``(``len``(sol)):` `            ``ans ``+``=` `pow``(``2``, i) ``*` `sol[``len``(sol) ``-` `1` `-` `i]` `        ``h[ans] ``=` `1` `        ``h[``4``] ``=` `1` `        ``h[``8``] ``=` `1` `        ``h[``9``] ``=` `1` `   `  `        ``# Last element in binary` `        ``last_element ``=` `sol[``len``(sol) ``-` `1``]` `   `  `        ``# if element is 1 add 0 after it else` `        ``# If 0 you can add either 0 or 1 after that` `        ``if` `last_element ``=``=` `1``:` `            ``sol.append(``0``)` `            ``numberWithNoConsecutiveOnes(n, sol)` `        ``else``:` `            ``sol.append(``1``)` `            ``numberWithNoConsecutiveOnes(n, sol)` `            ``sol.pop()` `            ``sol.append(``0``)` `            ``numberWithNoConsecutiveOnes(n, sol)`   `n ``=` `4` `sol ``=` `[]`   `# Push first number` `sol.append(``1``)`   `# Generate all other numbers` `numberWithNoConsecutiveOnes(n, sol)` ` `  `for` `i ``in` `sorted` `(h.keys()) :` `    ``print``(i, end ``=` `" "``)` `    `  `    ``# This code is contributed by divyesh072019.`

## C#

 `// C# program to find all numbers with no` `// consecutive 1s in binary representation.` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {` `    `  `    ``static` `SortedDictionary<``int``, ``int``> h = ``new` `SortedDictionary<``int``, ``int``>(); ` `                       `  `    ``static` `void` `numberWithNoConsecutiveOnes(``int` `n, List<``int``> sol)` `    ``{` `        ``// If it is in limit i.e. of n lengths in ` `        ``// binary` `        ``if` `(sol.Count <= n) {` `            ``int` `ans = 0;` `            ``for` `(``int` `i = 0; i < sol.Count; i++)` `                ``ans += (``int``)Math.Pow((``double``)2, i) * sol[sol.Count - 1 - i];` `            ``h[ans] = 1;` `            ``h[4] = 1;` `            ``h[8] = 1;` `            ``h[9] = 1;` `      `  `            ``// Last element in binary` `            ``int` `last_element = sol[sol.Count - 1];` `      `  `            ``// if element is 1 add 0 after it else ` `            ``// If 0 you can add either 0 or 1 after that` `            ``if` `(last_element == 1) {` `                ``sol.Add(0);` `                ``numberWithNoConsecutiveOnes(n, sol);` `            ``} ``else` `{` `                ``sol.Add(1);` `                ``numberWithNoConsecutiveOnes(n, sol);` `                ``sol.RemoveAt(sol.Count - 1);` `                ``sol.Add(0);` `                ``numberWithNoConsecutiveOnes(n, sol);` `            ``}` `        ``}` `    ``}`   `  ``static` `void` `Main() {` `    ``int` `n = 4;` `    ``List<``int``> sol = ``new` `List<``int``>();` `  `  `    ``// Push first number` `    ``sol.Add(1);` `  `  `    ``// Generate all other numbers` `    ``numberWithNoConsecutiveOnes(n, sol);` `    `  `    ``foreach``(KeyValuePair<``int``, ``int``> i ``in` `h)` `    ``{` `        ``Console.Write(i.Key + ``" "``);` `    ``}` `  ``}` `}`   `// This code is contributed by decode2207.`

## Javascript

 ``

Output :

`1 2 4 5 8 9 10`

Time Complexity : O(nlogn)

Auxiliary Space: O(n)

Related Post :
Count number of binary strings without consecutive 1â€™s
This article is contributed by Niteesh Kumar. 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.