# Count set bits in Bitwise XOR of all adjacent elements upto N

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 = 4Output:7Explanation:

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 = 7Output: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 * log_{2}N)**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

XisK, then the count of set bits in(X ^ (X – 1))must beK.

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(Log_{2}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. 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**.