Related Articles

# 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 = 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up