Related Articles

# 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 ``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

 ``
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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up