Skip to content
Related Articles

Related Articles

Improve Article
Count set bits in Bitwise XOR of all adjacent elements upto N
  • Last Updated : 10 Jun, 2021

Given a positive integer N, the task is to find the total count of set bits by performing Bitwise XOR on all possible adjacent elements in the range [0, N].

Examples:

Input: N = 4 
Output:
Explanation: 
Bitwise XOR of 0 and 1 = 001 and count of set bits = 1 
Bitwise XOR of 1 and 2 = 011 and count of set bits = 2 
Bitwise XOR of 2 and 3 = 001 and count of set bits = 1 
Bitwise XOR of 3 and 4 = 111 and count of set bits = 3 
Therefore, the total count of set bits by performing the XOR operation on all possible adjacent elements of the range [0, N] = (1 + 2 + 1 + 3) = 7

Input: N = 7 
Output: 11

 

Naive Approach: The simplest approach to solve this problem is to iterate over the range [0, N] and count all possible set bits by performing Bitwise XOR on each adjacent element over the range [0, N]. Finally, print the total count of all possible set bits.



Time Complexity: O(N * log2N) 
Auxiliary Space: O(1)

Efficient approach: To optimize the above approach, the idea is based on the following observations:

If the position of the rightmost set bit of X is K, then the count of set bits in (X ^ (X – 1)) must be K

Follow the steps below to solve the problem:

  • Initialize a variable, say bit_position to store all possible values of the right most bit over the range [0, N].
  • Initialize a variable, say total_set_bits to store the sum of all possible set bits by performing the Bitwise XOR operation on all possible adjacent elements over the range [0, N].
  • Iterate over the range [0, N] and Update N = N – (N + 1) / 2 and total_set_bits += ((N + 1) / 2 * bit_position).
  • Finally, print the value of total_set_bits.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count of set bits in Bitwise
// XOR of adjacent elements up to N
int countXORSetBitsAdjElemRange1_N(int N)
{
 
    // Stores count of set bits by Bitwise
    // XOR on adjacent elements of [0, N]
    int total_set_bits = 0;
 
    // Stores all possible values on
    // right most set bit over [0, N]
    int bit_Position = 1;
 
    // Iterate over the range [0, N]
    while (N) {
        total_set_bits += ((N + 1) / 2
                           * bit_Position);
 
        // Update N
        N -= (N + 1) / 2;
 
        // Update bit_Position
        bit_Position++;
    }
 
    return total_set_bits;
}
 
// Driver Code
int main()
{
    int N = 4;
 
    cout << countXORSetBitsAdjElemRange1_N(N);
 
    return 0;
}

Java




// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
   
class GFG{
   
// Function to count of set bits in Bitwise
// XOR of adjacent elements up to N
static int countXORSetBitsAdjElemRange1_N(int N)
{
     
    // Stores count of set bits by Bitwise
    // XOR on adjacent elements of [0, N]
    int total_set_bits = 0;
  
    // Stores all possible values on
    // right most set bit over [0, N]
    int bit_Position = 1;
  
    // Iterate over the range [0, N]
    while (N != 0)
    {
        total_set_bits += ((N + 1) / 2 *
                           bit_Position);
  
        // Update N
        N -= (N + 1) / 2;
  
        // Update bit_Position
        bit_Position++;
    }
    return total_set_bits;
}
   
// Driver Code
public static void main(String[] args)
{
    int N = 4;
  
    System.out.println(countXORSetBitsAdjElemRange1_N(N));
}
}
   
// This code is contributed by susmitakundugoaldanga

Python3




# Python3 program to implement
# the above approach
 
# Function to count of set bits in Bitwise
# XOR of adjacent elements up to N
def countXORSetBitsAdjElemRange1_N(N):
     
    # Stores count of set bits by Bitwise
    # XOR on adjacent elements of [0, N]
    total_set_bits = 0
 
    # Stores all possible values on
    # right most set bit over [0, N]
    bit_Position = 1
 
    # Iterate over the range [0, N]
    while (N):
        total_set_bits += ((N + 1) //
                            2 * bit_Position)
                             
        # Update N
        N -= (N + 1) // 2
 
        # Update bit_Position
        bit_Position += 1
 
    return total_set_bits
 
# Driver Code
if __name__ == '__main__':
     
    N = 4
     
    print(countXORSetBitsAdjElemRange1_N(N))
 
# This code is contributed by SURENDRA_GANGWAR

C#




// C# program to implement
// the above approach 
using System;
    
class GFG{
     
// Function to count of set bits in Bitwise
// XOR of adjacent elements up to N
static int countXORSetBitsAdjElemRange1_N(int N)
{
     
    // Stores count of set bits by Bitwise
    // XOR on adjacent elements of [0, N]
    int total_set_bits = 0;
   
    // Stores all possible values on
    // right most set bit over [0, N]
    int bit_Position = 1;
   
    // Iterate over the range [0, N]
    while (N != 0)
    {
        total_set_bits += ((N + 1) / 2 *
                           bit_Position);
   
        // Update N
        N -= (N + 1) / 2;
   
        // Update bit_Position
        bit_Position++;
    }
    return total_set_bits;
}
  
// Driver Code
public static void Main()
{
    int N = 4;
   
    Console.Write(countXORSetBitsAdjElemRange1_N(N));
}
}
 
// This code is contributed by code_hunt

Javascript




<script>
// Javascript program to implement
// the above approach
 
 
// Function to count of set bits in Bitwise
// XOR of adjacent elements up to N
function countXORSetBitsAdjElemRange1_N(N)
{
 
    // Stores count of set bits by Bitwise
    // XOR on adjacent elements of [0, N]
    let total_set_bits = 0;
 
    // Stores all possible values on
    // right most set bit over [0, N]
    let bit_Position = 1;
 
    // Iterate over the range [0, N]
    while (N) {
        total_set_bits += (Math.floor((N + 1) / 2) * bit_Position);
 
        // Update N
        N -= Math.floor((N + 1) / 2);
 
        // Update bit_Position
        bit_Position++;
    }
 
    return total_set_bits;
}
 
// Driver Code
let N = 4;
 
document.write(countXORSetBitsAdjElemRange1_N(N));
 
 
// This code is contributed by _saurabh_jaiswal
</script>
Output: 
7

 

Time complexity:O(Log2N) 
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.  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
Recommended Articles
Page :