1 to n bit numbers with no consecutive 1s in binary representation. (original) (raw)

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-

We make a solution vector sol and insert first bit 1 in it which will be the first number.
Now we check whether length of solution vector is less than or equal to n or not.
If it is so then we calculate the decimal number and store it into a map as it store numbers in sorted order.
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)

}

Try It Yourself

C++ `

// CPP program to find all numbers with no // consecutive 1s in binary representation. #include <bits/stdc++.h>

using namespace std; map<int, int> h;

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 += 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 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<Integer, Integer> 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<Integer, Integer> 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 sol = new List();

// 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)