Skip to content
Related Articles
Sum of bit differences for numbers from 0 to N
• Difficulty Level : Hard
• Last Updated : 11 Jun, 2021

Given a number N, the task is to calculate the total number of corresponding different bit in the binary representation for every consecutive number from 0 to N.
Examples:

Input: N = 5
Output:
Explanation:
Binary Representation of numbers are:
0 -> 000,
1 -> 001,
2 -> 010,
3 -> 011,
4 -> 100,
5 -> 101
Between 1 and 0 -> 1 bit is different
Between 2 and 1 -> 2 bits are different
Between 3 and 2 -> 1 bit is different
Between 4 and 3 -> 3 bits are different
Between 5 and 4 -> 1 bit is different
Total = 1 + 2 + 1 + 3 + 1 = 8
Input: N = 11
Output: 19

Naive Approach: The idea is to iterate from 0 to N and for each pair of a consecutive elements, find the number of different bits for each pair of elements using the approach discussed in this article.
Time Complexity: O(N*log N)
Auxiliary Space: (1)
Efficient Approach: For the efficient approach we have to observe the following:

```number:   1 2 3 4 5 6  7  8
bit_diff: 1 2 1 3 1 2  1  4
sum_diff: 1 3 4 7 8 10 11 15```

From the above calculations we can observe the following:

1. If N is a perfect power of 2, then the total sum of corresponding different bits from 0 to N is given by:

sum_diff = (2x+1-1)
where x = log2(N)

1.
2. If N is not a perfect power of 2, then it can be represented as sum of perfect power of 2 as:

N = 2a + 2b + … + 2x

1. Therefore the total sum of corresponding different bits from 0 to N can be calculated as:

sum_diff = (2a+1-1) + (2b+1-1) + … + (2x+1-1).

1.

For Examples:

If N = 8, then
The binary representation of 8 is “1000”
Hence 11 = 23
total count = (23+1 – 1)
total count = 8 – 1 = 7.
If N = 11, then
The binary representation of 11 is “1011”
Hence 11 = 23 + 21 + 20
=> total count = (23+1 – 1) + (21+1 – 1) + (20+1 – 1)
=> total count = 15 + 3 + 1 = 19.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to implement fast``// exponentiation``int` `binpow(``int` `a, ``int` `b)``{``    ``int` `res = 1;` `    ``while` `(b) {``        ``if` `(b & 1)``            ``res = res * a;``        ``a = a * a;``        ``b /= 2;``    ``}``    ``return` `res;``}` `// Function to return the value``// for powers of 2``int` `find(``int` `x)``{``    ``if` `(x == 0)``        ``return` `0;``    ``int` `p = log2(x);``    ``return` `binpow(2, p + 1) - 1;``}` `// Function to convert N into binary``string getBinary(``int` `n)``{``    ``// To store binary representation``    ``string ans = ``""``;` `    ``// Iterate each digit of n``    ``while` `(n) {``        ``int` `dig = n % 2;``        ``ans += to_string(dig);``        ``n /= 2;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to find difference in bits``int` `totalCountDifference(``int` `n)``{``    ``// Get binary representation``    ``string ans = getBinary(n);` `    ``// total number of bit``    ``// differences from 0 to N``    ``int` `req = 0;` `    ``// Iterate over each binary bit``    ``for` `(``int` `i = 0; i < ans.size(); i++) {` `        ``// If current bit is '1' then add``        ``// the count of current bit``        ``if` `(ans[i] == ``'1'``) {` `            ``req += find(binpow(2, i));``        ``}``    ``}``    ``return` `req;``}` `// Driver Code``int` `main()``{``    ``// Given Number``    ``int` `N = 5;` `    ``// Function Call``    ``cout << totalCountDifference(N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.Math;` `class` `GFG{``    ` `// Function to implement fast``// exponentiation``static` `int` `binpow(``int` `a, ``int` `b)``{``    ``int` `res = ``1``;` `    ``while` `(b > ``0``)``    ``{``        ``if` `(b % ``2` `== ``1``)``            ``res = res * a;``        ``a = a * a;``        ``b /= ``2``;``    ``}``    ``return` `res;``}` `// Function to return the``// value for powers of 2``static` `int` `find(``int` `x)``{``    ``if` `(x == ``0``)``        ``return` `0``;``        ` `    ``int` `p = (``int``)(Math.log(x) / Math.log(``2``));``    ``return` `binpow(``2``, p + ``1``) - ``1``;``}` `// Function to convert N into binary``static` `String getBinary(``int` `n)``{``    ` `    ``// To store the binary representation``    ``String ans = ``""``;` `    ``// Iterate each digit of n``    ``while` `(n > ``0``)``    ``{``        ``int` `dig = n % ``2``;``        ``ans += dig;``        ``n /= ``2``;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to find difference in bits``static` `int` `totalCountDifference(``int` `n)``{``    ` `    ``// Get binary representation``    ``String ans = getBinary(n);` `    ``// total number of bit``    ``// differences from 0 to N``    ``int` `req = ``0``;` `    ``// Iterate over each binary bit``    ``for``(``int` `i = ``0``; i < ans.length(); i++)``    ``{``       ` `       ``// If current bit is '1' then add``       ``// the count of current bit``       ``if` `(ans.charAt(i) == ``'1'``)``       ``{``           ``req += find(binpow(``2``, i));``       ``}``    ``}``    ``return` `req;``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ``// Given number``    ``int` `n = ``5``;``    ` `    ``System.out.print(totalCountDifference(n));``}``}` `// This code is contributed by spp____`

## Python3

 `# Python3 program for the above approach``from` `math ``import` `log` `# Function to implement fast``# exponentiation``def` `binpow(a, b):``    ` `    ``res ``=` `1``    ``while` `(b > ``0``):``        ``if` `(b ``%` `2` `=``=` `1``):``            ``res ``=` `res ``*` `a``        ``a ``=` `a ``*` `a``        ``b ``/``/``=` `2``    ``return` `res` `# Function to return the value``# for powers of 2``def` `find(x):``    ` `    ``if` `(x ``=``=` `0``):``        ``return` `0``    ``p ``=` `log(x) ``/` `log(``2``)``    ``return` `binpow(``2``, p ``+` `1``) ``-` `1` `# Function to convert N into binary``def` `getBinary(n):``    ` `    ``# To store binary representation``    ``ans ``=` `""``    ` `    ``# Iterate each digit of n``    ``while` `(n > ``0``):``        ``dig ``=` `n ``%` `2``        ``ans ``+``=` `str``(dig)``        ``n ``/``/``=` `2``    ` `    ``# Return binary representation``    ``return` `ans` `# Function to find difference in bits``def` `totalCountDifference(n):``    ` `    ``# Get binary representation``    ``ans ``=` `getBinary(n)``    ` `    ``# total number of bit``    ``# differences from 0 to N``    ``req ``=` `0``    ` `    ``# Iterate over each binary bit``    ``for` `i ``in` `range``(``len``(ans)):``        ` `        ``# If current bit is '1' then add``        ``# the count of current bit``        ``if` `(ans[i] ``=``=` `'1'``):``            ``req ``+``=` `find(binpow(``2``, i))``    ``return` `req` `# Driver Code` `# Given Number``N ``=` `5` `# Function Call``print``(totalCountDifference(N))` `# This code is contributed by shubhamsingh10`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG{``    ` `// Function to implement fast``// exponentiation``static` `int` `binpow(``int` `a, ``int` `b)``{``    ``int` `res = 1;` `    ``while` `(b > 0)``    ``{``        ``if` `(b % 2 == 1)``            ``res = res * a;``        ``a = a * a;``        ``b /= 2;``    ``}``    ``return` `res;``}` `// Function to return the``// value for powers of 2``static` `int` `find(``int` `x)``{``    ``if` `(x == 0)``        ``return` `0;``        ` `    ``int` `p = (``int``)(Math.Log(x) / Math.Log(2));``    ``return` `binpow(2, p + 1) - 1;``}` `// Function to convert N into binary``static` `String getBinary(``int` `n)``{``    ` `    ``// To store the binary representation``    ``String ans = ``""``;` `    ``// Iterate each digit of n``    ``while` `(n > 0)``    ``{``        ``int` `dig = n % 2;``        ``ans += dig;``        ``n /= 2;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to find difference in bits``static` `int` `totalCountDifference(``int` `n)``{``    ` `    ``// Get binary representation``    ``string` `ans = getBinary(n);` `    ``// total number of bit``    ``// differences from 0 to N``    ``int` `req = 0;` `    ``// Iterate over each binary bit``    ``for``(``int` `i = 0; i < ans.Length; i++)``    ``{``       ` `       ``// If current bit is '1' then add``       ``// the count of current bit``       ``if` `(ans[i] == ``'1'``)``       ``{``           ``req += find(binpow(2, i));``       ``}``    ``}``    ``return` `req;``}` `// Driver code``public` `static` `void` `Main()``{``    ``// Given number``    ``int` `n = 5;``    ` `    ``Console.Write(totalCountDifference(n));``}``}` `// This code is contributed by Nidhi_biet`

## Javascript

 ``
Output:
`8`

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

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up