# Count of integers up to N which represent a Binary number

• Difficulty Level : Medium
• Last Updated : 15 Apr, 2021

Given an integer N, the task is to count every number i from 1 to N (both inclusive) such that i is a binary representation of some integer where N can be any value within the range[1, 109]

Examples:

Input: N = 100
Output:
Explanation: Valid integers are 1, 10, 11, 100

Input: N = 20
Output:
Explanation: Valid integers are 1, 10, 11

Naive approach: Since maximum number of digits in N can be 10 so store every binary combination of 10 digits and then use Binary search or upper_bound to check the largest integer in the given range of N.
Time Complexity: O(MAX + log(MAX)) where MAX = 1024 (210)

Efficient approach: We can observe that for any value of N, the maximum number of such possible representations is 2count of digits of N – 1. Hence, we need to follow the following steps:

• Extract digits of N from right to left and store the position of the current digit in a variable ctr.
• If the current digit exceeds 1, it means that maximum possible representations using ctr digits can be obtained. Thus, set answer equal to 2ctr – 1.
• Otherwise, if the current digit is 1, then add 2ctr – 1 to the answer obtained so far.
• The final value obtained after traversing all the digits gives the answer.

Below is the implementation of the above approach:

## C++

 `// C++ Program to count the``// number of integers upto N``// which are of the form of``// binary representations` `#include ``using` `namespace` `std;` `// Function to return the count``int` `countBinaries(``int` `N)``{` `    ``int` `ctr = 1;``    ``int` `ans = 0;``    ``while` `(N > 0) {` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % 10 == 1) {` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += ``pow``(2, ctr - 1);``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % 10 > 1) {` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = ``pow``(2, ctr) - 1;``        ``}` `        ``ctr++;``        ``N /= 10;``    ``}` `    ``return` `ans;``}``// Driver Code``int` `main()``{` `    ``int` `N = 20;``    ``cout << countBinaries(N);` `    ``return` `0;``}`

## Java

 `// Java program to count the number``// of integers upto N which are of``// the form of binary representations``import` `java.util.*;``class` `GFG{` `// Function to return the count``static` `int` `countBinaries(``int` `N)``{``    ``int` `ctr = ``1``;``    ``int` `ans = ``0``;``    ``while` `(N > ``0``)``    ``{``        ` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % ``10` `== ``1``)``        ``{` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += Math.pow(``2``, ctr - ``1``);``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % ``10` `> ``1``)``        ``{` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = (``int``) (Math.pow(``2``, ctr) - ``1``);``        ``}``        ``ctr++;``        ``N /= ``10``;``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``20``;``    ``System.out.print(countBinaries(N));``}``}` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 program to count the``# number of integers upto N``# which are of the form of``# binary representations``from` `math ``import` `*` `# Function to return the count``def` `countBinaries(N):``    ` `    ``ctr ``=` `1``    ``ans ``=` `0``    ` `    ``while` `(N > ``0``):``        ` `        ``# If the current last``        ``# digit is 1``        ``if` `(N ``%` `10` `=``=` `1``):``            ` `            ``# Add 2^(ctr - 1) possible``            ``# integers to the answer``            ``ans ``+``=` `pow``(``2``, ctr ``-` `1``)` `        ``# If the current digit exceeds 1``        ``elif` `(N ``%` `10` `> ``1``):``            ` `            ``# Set answer as 2^ctr - 1``            ``# as all possible binary``            ``# integers with ctr number``            ``# of digits can be obtained``            ``ans ``=` `pow``(``2``, ctr) ``-` `1` `        ``ctr ``+``=` `1``        ``N ``/``/``=` `10` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `20``    ` `    ``print``(``int``(countBinaries(N)))` `# This code is contributed by Bhupendra_Singh`

## C#

 `// C# program to count the number``// of integers upto N which are of``// the form of binary representations``using` `System;` `class` `GFG{` `// Function to return the count``static` `int` `countBinaries(``int` `N)``{``    ``int` `ctr = 1;``    ``int` `ans = 0;``    ``while` `(N > 0)``    ``{``        ` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % 10 == 1)``        ``{``            ` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += (``int``)Math.Pow(2, ctr - 1);``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % 10 > 1)``        ``{` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = (``int``)(Math.Pow(2, ctr) - 1);``        ``}``        ``ctr++;``        ``N /= 10;``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 20;``    ``Console.Write(countBinaries(N));``}``}` `// This code is contributed by amal kumar choubey`

## Javascript

 ``

Output:

`3`

Time Complexity: O(M2) where M is the count of digits in N
Auxiliary Space: O(1)

Optimization: The above approach can be optimized by pre-computing the powers of 2 up to M (count of digits up to M of N) by the help of a prefix product array.

Below is the implementation of the optimized solution:

## C++

 `// C++ Program to count the``// number of integers upto N``// which are of the form of``// binary representations` `#include ``using` `namespace` `std;` `// Function to return the count``int` `countBinaries(``int` `N)``{``    ``// PreCompute and store``    ``// the powers of 2``    ``vector<``int``> powersOfTwo(11);` `    ``powersOfTwo[0] = 1;``    ``for` `(``int` `i = 1; i < 11; i++) {``        ``powersOfTwo[i]``= powersOfTwo[i - 1]``* 2;``    ``}` `    ``int` `ctr = 1;``    ``int` `ans = 0;``    ``while` `(N > 0) {` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % 10 == 1) {` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += powersOfTwo[ctr - 1];``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % 10 > 1) {` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = powersOfTwo[ctr] - 1;``        ``}` `        ``ctr++;``        ``N /= 10;``    ``}` `    ``return` `ans;``}``// Driver Code``int` `main()``{` `    ``int` `N = 20;``    ``cout << countBinaries(N);` `    ``return` `0;``}`

## Java

 `// Java program to count the number of``// integers upto N which are of the``// form of binary representations``import` `java.util.*;` `class` `GFG{` `// Function to return the count``static` `int` `countBinaries(``int` `N)``{``    ` `    ``// PreCompute and store``    ``// the powers of 2``    ``Vector powersOfTwo = ``new` `Vector(``11``);``    ``powersOfTwo.add(``1``);``    ` `    ``for``(``int` `i = ``1``; i < ``11``; i++)``    ``{``       ``powersOfTwo.add(powersOfTwo.get(i - ``1``) * ``2``);``    ``}` `    ``int` `ctr = ``1``;``    ``int` `ans = ``0``;``    ``while` `(N > ``0``)``    ``{` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % ``10` `== ``1``)``        ``{` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += powersOfTwo.get(ctr - ``1``);``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % ``10` `> ``1``)``        ``{` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = powersOfTwo.get(ctr) - ``1``;``        ``}``        ``ctr++;``        ``N /= ``10``;``    ``}``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``20``;``    ``System.out.print(countBinaries(N));``}``}` `// This code is contributed by amal kumar choubey`

## Python3

 `# Python3 program to count the``# number of integers upto N``# which are of the form of``# binary representations` `# Function to return the count``def` `countBinaries(N):` `    ``# PreCompute and store``    ``# the powers of 2``    ``powersOfTwo ``=` `[``0``] ``*` `11` `    ``powersOfTwo[``0``] ``=` `1``    ` `    ``for` `i ``in` `range``(``1``, ``11``):``        ``powersOfTwo[i] ``=` `powersOfTwo[i ``-` `1``] ``*` `2` `    ``ctr ``=` `1``    ``ans ``=` `0``    ` `    ``while` `(N > ``0``):` `        ``# If the current last``        ``# digit is 1``        ``if` `(N ``%` `10` `=``=` `1``):` `            ``# Add 2^(ctr - 1) possible``            ``# integers to the answer``            ``ans ``+``=` `powersOfTwo[ctr ``-` `1``]` `        ``# If the current digit exceeds 1``        ``elif` `(N ``%` `10` `> ``1``):` `            ``# Set answer as 2^ctr - 1``            ``# as all possible binary``            ``# integers with ctr number``            ``# of digits can be obtained``            ``ans ``=` `powersOfTwo[ctr] ``-` `1` `        ``ctr ``+``=` `1``        ``N ``=` `N ``/``/` `10` `    ``return` `ans` `# Driver code``N ``=` `20` `print``(countBinaries(N))` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to count the number of``// integers upto N which are of the``// form of binary representations``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Function to return the count``static` `int` `countBinaries(``int` `N)``{``    ` `    ``// PreCompute and store``    ``// the powers of 2``    ``List<``int``> powersOfTwo = ``new` `List<``int``>();``    ``powersOfTwo.Add(1);``    ` `    ``for``(``int` `i = 1; i < 11; i++)``    ``{``        ``powersOfTwo.Add(powersOfTwo[i - 1] * 2);``    ``}` `    ``int` `ctr = 1;``    ``int` `ans = 0;``    ``while` `(N > 0)``    ``{` `        ``// If the current last``        ``// digit is 1``        ``if` `(N % 10 == 1)``        ``{` `            ``// Add 2^(ctr - 1) possible``            ``// integers to the answer``            ``ans += powersOfTwo[ctr - 1];``        ``}` `        ``// If the current digit exceeds 1``        ``else` `if` `(N % 10 > 1)``        ``{` `            ``// Set answer as 2^ctr - 1``            ``// as all possible binary``            ``// integers with ctr number``            ``// of digits can be obtained``            ``ans = powersOfTwo[ctr] - 1;``        ``}``        ``ctr++;``        ``N /= 10;``    ``}``    ``return` `ans;``}` `// Driver Code``static` `public` `void` `Main ()``{``    ``int` `N = 20;``    ``Console.Write(countBinaries(N));``}``}` `// This code is contributed by ShubhamCoder`

## Javascript

 ``

Output:

`3`

Time Complexity: O(M)
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up