Related Articles

Related Articles

Count of total bits toggled/flipped in binary representation of 0 to N
  • Difficulty Level : Expert
  • Last Updated : 14 Sep, 2020

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:

  1. 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.



  2. Thus, we can conclude that the i th least significant bit will contribute N/(2 i) to the count of toggles.
  3. Hence, the sum of N/(2i) where i is in the range [0, log2N], gives the required answer.
  4. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count 
// the number of toggles 
// required to generate 
// all numbers from 0 to N 
  
#include <bits/stdc++.h> 
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; 

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 +=
  
        # Update N 
        N //= 2
      
    # Print the result 
    print(ans) 
  
# Driver code 
N = 5
  
solve(N) 
  
# This code is contributed by code_hunt

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

8

Time Complexity: O(log N) 
Auxiliary Space: O(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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :