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

• Difficulty Level : Medium
• Last Updated : 31 May, 2022

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 = 1;``            ``h = 1;``            ``h = 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.