GeeksforGeeks App
Open App
Browser
Continue

# 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 2N binary numbers.

• Therefore traverse from 0 to 2N 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 ``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 > getAllBinary(``int` `n)``{``    ``vector > 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 > 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> getAllBinary(``int` `n) {``    ``List> binary_nos = ``new` `List>();` `    ``// 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> 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

 ``

Output

```000
001
010
011
100
101
110
111```

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

My Personal Notes arrow_drop_up