Binary numbers of N digits

Given a positive integer number N. The task is to generate all the binary numbers of N digits. These binary numbers should be in ascending order.

Examples:

Input: 2
Output:
00
01
10
11
Explanation: These 4 are the only binary numbers having 2 digits.

Input: 3
Output:
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

Approach: For any digit length N, there will be 2^N binary numbers. 

• Therefore traverse from 0 to 2^N and convert every number to binary.
• Store each number and print it at the end.

Below is the implementation of the above approach.

C++

// C++ code to implement above approach
#include <bits/stdc++.h>
using namespace std;

// Function to convert number
// to binary of N bits
vector<int> convertToBinary(int num,
                            int length)
{
    // Vector to store the number
    vector<int> bits(length, 0);
    if (num == 0) {
        return bits;
    }

    int i = length - 1;
    while (num != 0) {
        bits[i--] = (num % 2);

        // Integer division
        // gives quotient
        num = num / 2;
    }
    return bits;
}

// Function to generate all
// N bit binary numbers
vector<vector<int> > getAllBinary(int n)
{
    vector<vector<int> > binary_nos;

    // Loop to generate the binary numbers
    for (int i = 0; i < pow(2, n); i++) {
        vector<int> bits =
            convertToBinary(i, n);
        binary_nos.push_back(bits);
    }

    return binary_nos;
}

// Driver code
int main()
{
    int N = 3;
    vector<vector<int> > binary_nos =
        getAllBinary(N);
    for (int i = 0; i < binary_nos.size();
           i++) {
        for (int j = 0;
                j < binary_nos[i].size(); j++)
            cout << binary_nos[i][j];
        cout << endl;
    }
    return 0;
}

Java

// Java code for the above approach
import java.io.*;

class GFG {

  // Function to convert number
  // to binary of N bits
  static int[] convertToBinary(int num,
                               int length)
  {

    // Vector to store the number
    int[] bits = new int[length];
    if (num == 0) {
      return bits;
    }

    int i = length - 1;
    while (num != 0) {
      bits[i--] = (num % 2);

      // Integer division
      // gives quotient
      num = num / 2;
    }
    return bits;
  }

  // Function to generate all
  // N bit binary numbers
  static int[][] getAllBinary(int n)
  {
    int[][] binary_nos = new int[(int)Math.pow(2,n)][];
    int k = 0;

    // Loop to generate the binary numbers
    for (int i = 0; i < Math.pow(2, n); i++) {
      int[] bits = convertToBinary(i, n);
      binary_nos[k++]= bits;
    }

    return binary_nos;
  }

  // Driver code
  public static void main (String[] args)
  {
    int N = 3;
    int[][] binary_nos = getAllBinary(N);
    for (int i = 0; i < binary_nos.length; i++) {
      for (int j = 0; j < binary_nos[i].length; j++)
        System.out.print(binary_nos[i][j]);
      System.out.println();
    }

  }
};

// This code is contributed by Potta Lokesh

Python3

# Python 3 code to implement above approach

# Function to convert number
# to binary of N bits
def convertToBinary(num,
                    length):

    # Vector to store the number
    bits = [0]*(length)
    if (num == 0):
        return bits

    i = length - 1
    while (num != 0):
        bits[i] = (num % 2)
        i -= 1

        # Integer division
        # gives quotient
        num = num // 2

    return bits

# Function to generate all
# N bit binary numbers
def getAllBinary(n):

    binary_nos = []

    # Loop to generate the binary numbers
    for i in range(pow(2, n)):
        bits = convertToBinary(i, n)
        binary_nos.append(bits)

    return binary_nos

# Driver code
if __name__ == "__main__":

    N = 3
    binary_nos = getAllBinary(N)
    for i in range(len(binary_nos)):
        for j in range(len(binary_nos[i])):
            print(binary_nos[i][j], end="")
        print()

        # This code is contributed by ukasp.

C#

// C# code for the above approach
using System;
using System.Collections.Generic;
public class GFG
{

  // Function to convert number
  // to binary of N bits
  static List<int> convertToBinary(int num, int length) {

    // List to store the number
    List<int> bits = new List<int>();
    if (num == 0) {
      bits.Add(0);
      bits.Add(0);
      bits.Add(0);
      return bits;
    }

    int i = length - 1;
    while (num != 0) {
      bits.Add(num % 2);

      // int division
      // gives quotient
      num = num / 2;
    }
    while(bits.Count<3)
      bits.Add(0);
    return bits;
  }

  // Function to generate all
  // N bit binary numbers
  static List<List<int>> getAllBinary(int n) {
    List<List<int>> binary_nos = new List<List<int>>();

    // Loop to generate the binary numbers
    for (int i = 0; i < Math.Pow(2, n); i++) {
      List<int> bits = convertToBinary(i, n);
      binary_nos.Add(bits);
    }

    return binary_nos;
  }

  // Driver code
  public static void Main(String[] args) {
    int N = 3;
    List<List<int>> binary_nos = getAllBinary(N);
    foreach(var st in binary_nos){
      foreach(var s in st){
        Console.Write(s);
      }
      Console.WriteLine();
    }
  }
}

// This code is contributed by Rajput-Ji

Javascript

<script>
    // JavaScript code to implement above approach

    // Function to convert number
    // to binary of N bits
    const convertToBinary = (num, length) => {
        // Vector to store the number
        let bits = new Array(length).fill(0);
        if (num == 0) {
            return bits;
        }

        let i = length - 1;
        while (num != 0) {
            bits[i--] = (num % 2);

            // Integer division
            // gives quotient
            num = parseInt(num / 2);
        }
        return bits;
    }

    // Function to generate all
    // N bit binary numbers
    const getAllBinary = (n) => {
        let binary_nos = [];

        // Loop to generate the binary numbers
        for (let i = 0; i < parseInt(Math.pow(2, n)); i++) {
            let bits = convertToBinary(i, n);
            binary_nos.push(bits);
        }

        return binary_nos;
    }

    // Driver code

    let N = 3;
    let binary_nos = getAllBinary(N);
    for (let i = 0; i < binary_nos.length;
        i++) {
        for (let j = 0;
            j < binary_nos[i].length; j++)
            document.write(binary_nos[i][j]);
        document.write("<br/>");
    }

    // This code is contributed by rakeshsahni

</script>

Output

000
001
010
011
100
101
110
111

Time Complexity: O(2^N)
Auxiliary Space: O(2^N)