# Count of total bits toggled/flipped in binary representation of 0 to N

Given an integer N, the task is to find the total number of bits toggled to obtain all numbers from 0 to N sequentially.

Examples:

Input: N = 5
Output:
Explanation:
Let’s represent numbers from 0 to 5 in binary:
000 -> 001 : 1 bit toggled
001 -> 010 : 2 bits toggled
010 -> 011 : 1 bit toggled
011 -> 100 : 3 bits toggled
100 -> 101 : 1 bit toggled
Hence, 8 bits toggled

Input: N = 1
Output: 1

Approach:
Follow the steps below to solve the problems:

• The following observations need to be made to solve the problem:

The rightmost bit toggles every time.
(000) -> (001) -> (010) -> (011
So, the contribution of this bit to the count will be N
The next bit toggles after every 2 numbers.
(000) -> (001) -> (010) -> (011) -> (100)
Hence, the contribution of this bit to the count will be N/2.

• Thus, we can conclude that the i th least significant bit will contribute N/(2 i) to the count of toggles.
• Hence, the sum of N/(2i) where i is in the range [0, log2N], gives the required answer.
• Hence, initialize a variable ans. Add N to ans and update N to N/2. Repeat this process until N becomes 0, to get the final result.

Below is the implementation of the above approach:

## C++

 `// C++ program to count ``// the number of toggles ``// required to generate ``// all numbers from 0 to N ` `#include ``using` `namespace` `std; ` `typedef` `long` `long` `int` `ll; ` `// Function to count and print ``// the required number of ``// toggles ``void` `solve(ll N) ``{ ``    ``// Store the count ``    ``// of toggles ``    ``ll ans = 0; ` `    ``while` `(N != 0) { ` `        ``// Add the contribution ``        ``// of the current LSB ``        ``ans += N; ` `        ``// Update N ``        ``N /= 2; ``    ``} ``    ``// Print the result ``    ``cout << ans << endl; ``} ``// Driver code ``int` `main() ``{ ``    ``ll N = 5; ``    ``solve(N); ``    ``return` `0; ``} `

## Java

 `// Java program to count the ``// number of toggles required ``// to generate all numbers ``// from 0 to N ``class` `GFG{ ` `// Function to count and print ``// the required number of ``// toggles ``static` `void` `solve(``int` `N) ``{ ``    ` `    ``// Store the count ``    ``// of toggles ``    ``int` `ans = ``0``; ` `    ``while` `(N != ``0``) ``    ``{ ``        ` `        ``// Add the contribution ``        ``// of the current LSB ``        ``ans += N; ` `        ``// Update N ``        ``N /= ``2``; ``    ``} ``    ` `    ``// Print the result ``    ``System.out.println(ans); ``} ` `// Driver code ``public` `static` `void` `main(String []args) ``{ ``    ``int` `N = ``5``; ``    ` `    ``solve(N); ``} ``} ` `// This code is contributed by Ritik Bansal `

## Python3

 `# Python3 program to count ``# the number of toggles ``# required to generate ``# all numbers from 0 to N ` `# Function to count and pr ``# the required number of ``# toggles ``def` `solve(N): ``    ` `    ``# Store the count ``    ``# of toggles ``    ``ans ``=` `0` `    ``while` `(N !``=` `0``): ` `        ``# Add the contribution ``        ``# of the current LSB ``        ``ans ``+``=` `N ` `        ``# Update N ``        ``N ``/``/``=` `2``    ` `    ``# Print the result ``    ``print``(ans) ` `# Driver code ``N ``=` `5` `solve(N) ` `# This code is contributed by code_hunt`

## C#

 `// C# program to count the ``// number of toggles required``// to generate all numbers ``// from 0 to N``using` `System;` `class` `GFG{` `// Function to count and print``// the required number of``// toggles``static` `void` `solve(``int` `N)``{``    ` `    ``// Store the count``    ``// of toggles``    ``int` `ans = 0;` `    ``while` `(N != 0)``    ``{``        ` `        ``// Add the contribution``        ``// of the current LSB``        ``ans += N;` `        ``// Update N``        ``N /= 2;``    ``}``    ` `    ``// Print the result``    ``Console.Write(ans);``}` `// Driver code``public` `static` `void` `Main(``string` `[]args)``{``    ``int` `N = 5;``    ` `    ``solve(N);``}``}` `// This code is contributed by rock_cool`

## Javascript

 ``

Output:

`8`

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

Previous
Next