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:8

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

For Naive and Efficient Approach please refer to the previous post of this article.

**More Efficient Approach:** To optimize the above methods, we can use Recursion. To solve the problem, the following observations need to be made

Number: 0 1 2 3 4 5 6 7 Difference: 1 2 1 3 1 2 1 4 Sum: 1 3 4 7 8 10 11 15

We can observe that for **N = [1, 2, 3, 4, …..]**, the sum of different bits in consecutive elements forms the sequence **[1, 3, 4, 7, 8, ……]**. Hence, **N ^{th}** term of this series will be our required answer, which can be calculated as:

a(n) = a(n / 2) + n; with base case as a(1) = 1

Below is the implementation for above Recursive approach:

## C++

`// C++ program to find the sum ` `// of bit differences between ` `// consecutive numbers ` `// from 0 to N using recursion ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Recursive function to find sum ` `// of different bits between ` `// consecutive numbers from 0 to N ` `int` `totalCountDifference(` `int` `n) ` `{ ` ` ` ` ` `// Base case ` ` ` `if` `(n == 1) ` ` ` `return` `1; ` ` ` ` ` `// Calculate the Nth term ` ` ` `return` `n ` ` ` `+ totalCountDifference(n / 2); ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `// Given Number ` ` ` `int` `N = 5; ` ` ` ` ` `// Function Call ` ` ` `cout << totalCountDifference(N); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to find the sum ` `// of bit differences between ` `// consecutive numbers from ` `// 0 to N using recursion ` `class` `GFG{ ` ` ` `// Recursive function to find sum ` `// of different bits between ` `// consecutive numbers from 0 to N ` `static` `int` `totalCountDifference(` `int` `n) ` `{ ` ` ` ` ` `// Base case ` ` ` `if` `(n == ` `1` `) ` ` ` `return` `1` `; ` ` ` ` ` `// Calculate the Nth term ` ` ` `return` `n + totalCountDifference(n / ` `2` `); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` ` ` ` ` `// Given number ` ` ` `int` `N = ` `5` `; ` ` ` ` ` `// Function call ` ` ` `System.out.println(totalCountDifference(N)); ` `} ` `} ` ` ` `// This code is contributed by himanshu77 ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find the sum ` `# of bit differences between ` `# consecutive numbers from ` `# 0 to N using recursion ` ` ` `# Recursive function to find sum ` `# of different bits between ` `# consecutive numbers from 0 to N ` `def` `totalCountDifference (n): ` ` ` ` ` `# Base case ` ` ` `if` `(n ` `=` `=` `1` `): ` ` ` `return` `1` ` ` ` ` `# Calculate the Nth term ` ` ` `return` `n ` `+` `totalCountDifference(n ` `/` `/` `2` `) ` ` ` `# Driver code ` ` ` `# Given number ` `N ` `=` `5` ` ` `# Function call ` `print` `(totalCountDifference(N)) ` ` ` `# This code is contributed by himanshu77 ` |

*chevron_right*

*filter_none*

## C#

`// C# program to find the sum ` `// of bit differences between ` `// consecutive numbers from ` `// 0 to N using recursion ` `using` `System; ` ` ` `class` `GFG{ ` ` ` `// Recursive function to find sum ` `// of different bits between ` `// consecutive numbers from 0 to N ` `static` `int` `totalCountDifference(` `int` `n) ` `{ ` ` ` ` ` `// Base case ` ` ` `if` `(n == 1) ` ` ` `return` `1; ` ` ` ` ` `// Calculate the Nth term ` ` ` `return` `n + totalCountDifference(n / 2); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `Main() ` `{ ` ` ` ` ` `// Given number ` ` ` `int` `N = 5; ` ` ` ` ` `// Function call ` ` ` `Console.WriteLine(totalCountDifference(N)); ` `} ` `} ` ` ` `// This code is contributed by himanshu77 ` |

*chevron_right*

*filter_none*

**Output:**

8

**Time Complexity:** O(log_{2}N)

**Auxiliary Space:** O(1)

## Recommended Posts:

- Sum of bit differences for numbers from 0 to N
- Sum of bit differences among all pairs
- Minimum bit flips such that every K consecutive bits contain at least one set bit
- Sequence with sum K and minimum sum of absolute differences between consecutive elements
- Sum of all the prime numbers with the maximum position of set bit ≤ D
- Count of 1-bit and 2-bit characters in the given binary string
- Maximize the sum of differences of consecutive elements after removing exactly K elements
- Array formed using sum of absolute differences of that element with all other elements
- Sum of all differences between Maximum and Minimum of increasing Subarrays
- Count of numbers having only 1 set bit in the range [0, n]
- Maximum set bit count from pairs of integers from 0 to N that yields a sum as N
- Turn off the rightmost set bit | Set 2
- 1 to n bit numbers with no consecutive 1s in binary representation.
- Print N-bit binary numbers having more 1’s than 0’s in all prefixes
- Find average of two numbers using bit operation
- Count of N-bit binary numbers without leading zeros
- Count of numbers having only one unset bit in a range [L,R]
- Count of numbers satisfying m + sum(m) + sum(sum(m)) = N
- Minimum elements to be inserted in Array to make adjacent differences equal
- Sum of sum of all subsets of a set formed by first N natural numbers

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.