Open in App
Not now

# Generate all binary numbers in range [L, R] with same length

• Last Updated : 23 Dec, 2021

Given two positive integer numbers L and R. The task is to convert all the numbers from L to R to binary number. The length of all binary numbers should be same.

Examples:

Input: L = 2, R = 4
Output:
010
011
100
Explanation: The binary representation of the numbers: 2 = 10, 3 = 11 and 4 = 100.
For the numbers to have same length one preceding 0 is added to the binary representation of both 3 and 4.

Input: L = 2, R = 8
Output:
0010
0011
0100
0101
0110
0111
1000

Approach: Follow the approach mentioned below to solve the problem.

• To determine the length of resultant binary numbers, take log of R+1 to the base 2.
• Then traverse from L to R and convert every number to binary of determined length.
• Store each number and print it at the end.

Below is the implementation of the above approach

## C++

 `// C++ code to implement the approach` `#include ` `using` `namespace` `std;`   `// Function to convert a number to binary` `vector<``int``> convertToBinary(``int` `num, ` `                            ``int` `length)` `{` `    ``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 convert all numbers ` `// in range [L, R] to binary of ` `// same length` `vector > getAllBinary(``int` `l, ` `                                  ``int` `r)` `{`   `    ``// Length of the binary numbers` `    ``int` `n = (``int``) ``ceil``(``log``(r+1) / ``log` `(2));`   `    ``vector > binary_nos;`   `    ``for` `(``int` `i = l; i <= r; i++) {` `        ``vector<``int``> bits = ` `            ``convertToBinary(i, n);` `        ``binary_nos.push_back(bits);` `    ``}`   `    ``return` `binary_nos;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `L = 2, R = 8;` `    ``vector > binary_nos =` `        ``getAllBinary(L, R);` `    ``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 to implement the approach` `import` `java.util.*;` `public` `class` `GFG` `{`   `  ``// Function to convert a number to binary` `  ``static` `ArrayList convertToBinary(``int` `num, ` `                                            ``int` `length)` `  ``{` `    ``ArrayList bits= ``new` `ArrayList();` `    ``for``(``int` `i = ``0``; i < length; i++) {` `      ``bits.add(``0``);` `    ``}` `    ``if` `(num == ``0``) {` `      ``return` `bits;` `    ``}`   `    ``int` `i = length - ``1``;` `    ``while` `(num != ``0``) {` `      ``bits.set(i, (num % ``2``));` `      ``i = i - ``1``;`   `      ``// Integer division` `      ``// gives quotient` `      ``num = num / ``2``;` `    ``}`   `    ``return` `bits;` `  ``}`   `  ``// Function to convert all numbers ` `  ``// in range [L, R] to binary of ` `  ``// same length` `  ``static` `ArrayList > getAllBinary(``int` `l, ` `                                                     ``int` `r)` `  ``{`   `    ``// Length of the binary numbers` `    ``double` `x = Math.log(r+``1``);` `    ``double` `y = Math.log (``2``);` `    ``int` `n = (``int``) Math.ceil(x / y);`   `    ``ArrayList > binary_nos = ` `      ``new` `ArrayList >();`   `    ``for` `(``int` `i = l; i <= r; i++) {` `      ``ArrayList bits = ` `        ``convertToBinary(i, n);` `      ``binary_nos.add(bits);` `    ``}`   `    ``return` `binary_nos;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String args[])` `  ``{` `    ``int` `L = ``2``, R = ``8``;` `    ``ArrayList > binary_nos =` `      ``getAllBinary(L, R);` `    ``for` `(``int` `i = ``0``; i < binary_nos.size(); i++) {` `      ``for` `(``int` `j = ``0``; j < binary_nos.get(i).size(); j++) {` `        ``System.out.print(binary_nos.get(i).get(j));` `      ``}` `      ``System.out.println();` `    ``}` `  ``}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python 3 code to implement the approach` `import` `math`   `# Function to convert a number to binary` `def` `convertToBinary(num, length):`   `    ``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 convert all numbers` `# in range [L, R] to binary of` `# same length` `def` `getAllBinary(l, r):`   `    ``# Length of the binary numbers` `    ``n ``=` `int``(math.ceil(math.log(r``+``1``)``/` `math.log(``2``)))`   `    ``binary_nos ``=` `[]`   `    ``for` `i ``in` `range``(l, r ``+` `1``):` `        ``bits ``=` `convertToBinary(i, n)` `        ``binary_nos.append(bits)`   `    ``return` `binary_nos`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``L ``=` `2` `    ``R ``=` `8` `    ``binary_nos ``=` `getAllBinary(L, R)` `    ``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 to implement the approach` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `GFG` `{`   `  ``// Function to convert a number to binary` `  ``static` `List<``int``> convertToBinary(``int` `num, ``int` `length)` `  ``{` `    ``List<``int``> bits = ``new` `List<``int``>();` `    ``int` `i;` `    ``for` `(i = 0; i < length; i++)` `    ``{` `      ``bits.Add(0);` `    ``}` `    ``if` `(num == 0)` `    ``{` `      ``return` `bits;` `    ``}`   `    ``i = length - 1;` `    ``while` `(num != 0)` `    ``{` `      ``bits[i] = (num % 2);` `      ``i = i - 1;`   `      ``// Integer division` `      ``// gives quotient` `      ``num = num / 2;` `    ``}`   `    ``return` `bits;` `  ``}`   `  ``// Function to convert all numbers ` `  ``// in range [L, R] to binary of ` `  ``// same length` `  ``static` `List> getAllBinary(``int` `l, ``int` `r)` `  ``{`   `    ``// Length of the binary numbers` `    ``double` `x = Math.Log(r + 1);` `    ``double` `y = Math.Log(2);` `    ``int` `n = (``int``)Math.Ceiling(x / y);`   `    ``List> binary_nos = ``new` `List>();`   `    ``for` `(``int` `i = l; i <= r; i++)` `    ``{` `      ``List<``int``> bits = convertToBinary(i, n);` `      ``binary_nos.Add(bits);` `    ``}`   `    ``return` `binary_nos;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main()` `  ``{` `    ``int` `L = 2, R = 8;` `    ``List> binary_nos = getAllBinary(L, R);` `    ``for` `(``int` `i = 0; i < binary_nos.Count; i++)` `    ``{` `      ``for` `(``int` `j = 0; j < binary_nos[i].Count; j++)` `      ``{` `        ``Console.Write(binary_nos[i][j]);` `      ``}` `      ``Console.WriteLine(``""``);` `    ``}` `  ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

```0010
0011
0100
0101
0110
0111
1000```

Time Complexity: O(N * logR) where N = (R – L + 1)
Auxiliary Space: O(N * logR)

My Personal Notes arrow_drop_up
Related Articles