GeeksforGeeks App
Open App
Browser
Continue

Bits manipulation (Important tactics)

1. Compute XOR from 1 to n (direct method):

The  problem can be solved based on the following observations:

Say x = n%4. The XOR value depends on the value if x. If

• x = 0, then the answer is n.
• x = 1, then answer is 1.
• x = 2, then answer is n+1.
• x = 3, then answer is 0.

Below is the implementation of the above approach.

CPP

 `// Direct XOR of all numbers from 1 to n``int` `computeXOR(``int` `n)``{``    ``if` `(n % 4 == 0)``        ``return` `n;``    ``if` `(n % 4 == 1)``        ``return` `1;``    ``if` `(n % 4 == 2)``        ``return` `n + 1;``    ``else``        ``return` `0;``}`

Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG``{``  ` `  ``// Direct XOR of all numbers from 1 to n``  ``public` `static` `int` `computeXOR(``int` `n)``  ``{``    ``if` `(n % ``4` `== ``0``)``      ``return` `n;``    ``if` `(n % ``4` `== ``1``)``      ``return` `1``;``    ``if` `(n % ``4` `== ``2``)``      ``return` `n + ``1``;``    ``else``      ``return` `0``;``  ``}` `  ``public` `static` `void` `main (String[] args) {` `  ``}``}` `// This code is contributed by akashish__`

Python3

 `# Direct XOR of all numbers from 1 to n``def` `computeXOR(n):``    ``if` `(n ``%` `4` `is` `0``):``        ``return` `n``    ``if` `(n ``%` `4` `is` `1``):``        ``return` `1``    ``if` `(n ``%` `4` `is` `2``):``        ``return` `n ``+` `1``    ``else``:``        ``return` `0` `      ` `# This code is contributed by akashish__`

C#

 `using` `System;``public` `class` `GFG``{` `  ``// Direct XOR of all numbers from 1 to n``  ``public` `static` `int` `computeXOR(``int` `n)``  ``{` `    ``if` `(n % 4 == 0)` `      ``return` `n;` `    ``if` `(n % 4 == 1)` `      ``return` `1;` `    ``if` `(n % 4 == 2)` `      ``return` `n + 1;` `    ``else` `      ``return` `0;` `  ``}``  ``public` `static` `void` `Main(){}`  `}` `// This code is contributed by akashish__`

Javascript

 ``

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

Refer Compute XOR from 1 to n for details.

2. Count of numbers (x) smaller than or equal to n such that n+x = n^x:

The count of such numbers x can be counted using the following mathematical trick.

The count = pow(2, count of zero bits).

C++

 `// Count of numbers (x) smaller than or equal to n such that n+x = n^x:``// here unset bits means zero bits``#include ``using` `namespace` `std;` `// function to count number of values less than``// equal to n that satisfy the given condition``int` `countValues(``int` `n)``{``    ``// unset_bits keeps track of count of un-set``    ``// bits in binary representation of n``    ``int` `unset_bits=0;``    ``while` `(n)``    ``{``        ``if` `((n & 1) == 0)``            ``unset_bits++;``        ``n=n>>1;``    ``}` `    ``// Return 2 ^ unset_bits i.e. pow(2,count of zero bits)``    ``return` `1 << unset_bits;``}` `// Driver code``int` `main()``{``    ``int` `n = 15;``    ``cout << countValues(n);``    ``return` `0;``}` `// contributed by akashish__`

Java

 `// Count of numbers (x) smaller than or equal to n such that n+x = n^x:``// here unset bits means zero bits``import` `java.io.*;``class` `GFG``{` `  ``// function to count number of values less than``  ``// equal to n that satisfy the given condition``  ``public` `static` `int` `countValues(``int` `n)``  ``{``    ``// unset_bits keeps track of count of un-set``    ``// bits in binary representation of n``    ``int` `unset_bits = ``0``;``    ``while` `(n > ``0``)``    ``{``      ``if` `((n & ``1``) == ``0``)``        ``unset_bits++;``      ``n = n>>``1``;``    ``}` `    ``// Return 2 ^ unset_bits i.e. pow(2,count of zero bits)``    ``return` `1` `<< unset_bits;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args) {``    ``int` `n = ``15``;``    ``System.out.print(countValues(n));``  ``}``}` `// This code is contributed by poojaagrawal2.`

Python3

 `# Count of numbers (x) smaller than or equal to n such that n+x = n^x:``# here unset bits means zero bits` `# function to count number of values less than``# equal to n that satisfy the given condition``def` `countValues(n):``  ` `    ``# unset_bits keeps track of count of un-set``    ``# bits in binary representation of n``    ``unset_bits``=``0``    ``while` `(n):``        ``if` `((n & ``1``) ``=``=` `0``):``            ``unset_bits``+``=``1``        ``n``=``n>>``1` `    ``# Return 2 ^ unset_bits i.e. pow(2,count of zero bits)``    ``return` `1` `<< unset_bits` `# Driver code``n ``=` `15``print``(countValues(n))` `# This code is contributed by akashish__`

C#

 `// C# code to implement the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `  ``// Count of numbers (x) smaller than or equal to n such that n+x = n^x:``  ``// here unset bits means zero bits` `  ``// function to count number of values less than``  ``// equal to n that satisfy the given condition``  ``static` `int` `countValues(``int` `n)``  ``{` `    ``// unset_bits keeps track of count of un-set``    ``// bits in binary representation of n``    ``int` `unset_bits = 0;``    ``while` `(n > 0)``    ``{``      ``if` `((n & 1) == 0)``        ``unset_bits++;``      ``n = n>>1;``    ``}` `    ``// Return 2 ^ unset_bits i.e. pow(2,count of zero bits)``    ``return` `1 << unset_bits;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `n = 15;``    ``Console.Write(countValues(n));``  ``}``}` `// This code is contributed by agrawalpoojaa976.`

Javascript

 `// Count of numbers (x) smaller than or equal to n such that n+x = n^x:``// here unset bits means zero bits` `// function to count number of values less than``// equal to n that satisfy the given condition``function` `countValues(n)``{``    ``// unset_bits keeps track of count of un-set``    ``// bits in binary representation of n``    ``let unset_bits=0;``    ``while` `(n)``    ``{``        ``if` `((n & 1) == 0)``            ``unset_bits++;``        ``n=n>>1;``    ``}` `    ``// Return 2 ^ unset_bits i.e. pow(2,count of zero bits)``    ``return` `1 << unset_bits;``}` `// Driver code``    ``let n = 15;``    ``document.write(countValues(n));`

Output

`1`

Refer Equal Sum and XOR for details.

Time complexity :- O(1)

Auxiliary Space: O(1)

3. How to know if a number is a power of 2?

This can be solved based on the following fact:

If a number N is a power of 2, then the bitwise AND of N and N-1 will be 0. But this will not work if N is 0. So just check these two conditions, if any of these two conditions is true.

Refer check if a number is power of two for details.

Below is the implementation of the above approach.

CPP

 `//  Function to check if x is power of 2``bool` `isPowerOfTwo(``int` `x)``{``     ``// First x in the below expression is``     ``// for  the case when x is 0``     ``return` `x && (!(x & (x - 1)));``}`

Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {` `  ``//  Function to check if x is power of 2``  ``static` `public` `boolean` `isPowerOfTwo(``int` `x)``  ``{` `    ``// First x in the below expression is``    ``// for  the case when x is 0``    ``return` `(x != ``0``) && ((x & (x - ``1``)) == ``0``);``  ``}` `  ``public` `static` `void` `main (String[] args) {`  `  ``}``}``// contributed by akashish__`

Python3

 `#  Function to check if x is power of 2``def` `isPowerOfTwo(x):``  ` `  ``# First x in the below expression is``  ``# for  the case when x is 0``  ``return` `x ``and` `(``not``(x & (x ``-` `1``)))` `# This code is contributed by akashish__`

C#

 `using` `System;` `public` `class` `GFG{``  ` `  ``//  Function to check if x is power of 2``static` `public` `bool` `isPowerOfTwo(``int` `x)``{``     ``// First x in the below expression is``     ``// for  the case when x is 0``       ``return` `(x != 0) && ((x & (x - 1)) == 0);``}` `    ``static` `public` `void` `Main (){` `    ``}``}` `// This code is contributed by akashish__`

Javascript

 `//  Function to check if x is power of 2``function` `isPowerOfTwo(x)``{``     ``// First x in the below expression is``     ``// for  the case when x is 0``     ``return` `x && (!(x & (x - 1)));``}` `// This code is contributed by akashish__`

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

4. Find XOR of all subsets of a set

We can do it in O(1) time. The answer is always 0 if the given set has more than one element. For sets with a single element, the answer is the value of the single element.

Refer XOR of the XOR’s of all subsets for details.

5. Find the number of leading, trailing zeroes and number of 1’s

We can quickly find the number of leading, trailing zeroes and number of 1’s in a binary code of an integer in C++ using GCC.

It can be done by using inbuilt functions i.e.

Number of trailing zeroes : __builtin_ctz(x)
Number of 1-bits: __builtin_popcount(x)

Refer GCC inbuilt functions for details.

CPP

 `// Conversion into Binary code` `#include ``using` `namespace` `std;` `int` `main()``{``    ``auto` `number = 0b011;``    ``cout << number;``    ``return` `0;``}`

Java

 `/*package whatever //do not write package name here */``// Conversion into Binary code``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `number = 0b011;``        ``System.out.println(number);``    ``}``}` `// This code is contributed by akashish__`

Python3

 `# Python Code``number ``=` `0b011``print``(number)` `# This code is contributed by akashish__`

C#

 `// Conversion into Binary code` `using` `System;` `public` `class` `GFG {` `    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``int` `number = 0b011;``        ``Console.WriteLine(number);``    ``}``}` `// This code is contributed by karthik`

Javascript

 `// Conversion into Binary code` `let number = 0b011;``console.log(number);`

Output

`3`

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

7. The Quickest way to swap two numbers:

Two numbers can be swapped easily using the following bitwise operations:

a ^= b;
b ^= a;
a ^= b;

C++

 `#include ``using` `namespace` `std;` `int` `main()``{``    ``int` `a = 5;``      ``int` `b = 7;``      ``cout<<``"Before Swapping, a = "``<

Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.*;` `class` `GFG {``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `a = ``5``;``    ``int` `b = ``7``;``    ``System.out.print(``"Before Swapping, a = "``);``    ``System.out.print(a);``    ``System.out.print(``" "``);``    ``System.out.print(``"b = "``);``    ``System.out.print(b);``    ``System.out.println(``""``);``    ``a ^= b;``    ``b ^= a;``    ``a ^= b;``    ``System.out.print(``"After Swapping, a = "``);``    ``System.out.print(a);``    ``System.out.print(``" "``);``    ``System.out.print(``"b = "``);``    ``System.out.print(b);``  ``}``}` `// This code is contributed by akashish__`

Python3

 `a ``=` `5``b ``=` `7``print``(``"Before Swapping, a = "``,a,``" "``,``"b = "``,b)``a ^``=` `b``b ^``=` `a``a ^``=` `b``print``(``"After Swapping, a = "``,a,``" "``,``"b = "``,b)` `# This code is contributed by akashish__`

C#

 `using` `System;` `public` `class` `GFG {` `    ``static` `public` `void` `Main()``    ``{` `        ``int` `a = 5;``        ``int` `b = 7;``        ``Console.WriteLine(``"Before Swapping, a = "` `+ a + ``" "``                          ``+ ``"b = "` `+ b);``        ``a ^= b;``        ``b ^= a;``        ``a ^= b;``        ``Console.WriteLine(``"After Swapping, a = "` `+ a + ``" "``                          ``+ ``"b = "` `+ b);``    ``}``}``// This code is contributed by akashish__`

Javascript

 `let a = 5;``let b = 7;``console.log(``"Before Swapping, a = "` `, a , ``" "` `, ``"b = "` `, b);``a ^= b;``b ^= a;``a ^= b;``console.log(``"After Swapping, a = "` `, a , ``" "` `, ``"b = "` `, b);` `// This code is contributed by akashish__`

Output

```Before Swapping, a = 5 b = 7
After Swapping, a = 7 b = 5```

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

Refer swap two numbers for more details.

9. Finding the most significant set bit (MSB):

We can find the most significant set bit in O(1) time for a fixed size integer. For example below code is for 32-bit integer.

C++

 `int` `setBitNumber(``int` `n)``{``    ``// Below steps set bits after``    ``// MSB (including MSB)` `    ``// Suppose n is 273 (binary``    ``// is 100010001). It does following``    ``// 100010001 | 010001000 = 110011001``    ``n |= n >> 1;` `    ``// This makes sure 4 bits``    ``// (From MSB and including MSB)``    ``// are set. It does following``    ``// 110011001 | 001100110 = 111111111``    ``n |= n >> 2;` `    ``n |= n >> 4;``    ``n |= n >> 8;``    ``n |= n >> 16;` `    ``// Increment n by 1 so that``    ``// there is only one set bit``    ``// which is just before original``    ``// MSB. n now becomes 1000000000``    ``n = n + 1;` `    ``// Return original MSB after shifting.``    ``// n now becomes 100000000``    ``return` `(n >> 1);``}`

Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {` `  ``public` `static` `int` `setBitNumber(``int` `n)``  ``{``    ``// Below steps set bits after``    ``// MSB (including MSB)` `    ``// Suppose n is 273 (binary``    ``// is 100010001). It does following``    ``// 100010001 | 010001000 = 110011001``    ``n |= n >> ``1``;` `    ``// This makes sure 4 bits``    ``// (From MSB and including MSB)``    ``// are set. It does following``    ``// 110011001 | 001100110 = 111111111``    ``n |= n >> ``2``;` `    ``n |= n >> ``4``;``    ``n |= n >> ``8``;``    ``n |= n >> ``16``;` `    ``// Increment n by 1 so that``    ``// there is only one set bit``    ``// which is just before original``    ``// MSB. n now becomes 1000000000``    ``n = n + ``1``;` `    ``// Return original MSB after shifting.``    ``// n now becomes 100000000``    ``return` `(n >> ``1``);``  ``}`  `  ``public` `static` `void` `main (String[] args) {``  ``}``}` `// This code is contributed by akashish__`

Python3

 `def` `setBitNumber(n):``    ``# Below steps set bits after``    ``# MSB (including MSB)` `    ``# Suppose n is 273 (binary``    ``# is 100010001). It does following``    ``# 100010001 | 010001000 = 110011001``    ``n |``=` `n >> ``1` `    ``# This makes sure 4 bits``    ``# (From MSB and including MSB)``    ``# are set. It does following``    ``# 110011001 | 001100110 = 111111111``    ``n |``=` `n >> ``2` `    ``n |``=` `n >> ``4``    ``n |``=` `n >> ``8``    ``n |``=` `n >> ``16` `    ``# Increment n by 1 so that``    ``# there is only one set bit``    ``# which is just before original``    ``# MSB. n now becomes 1000000000``    ``n ``=` `n ``+` `1` `    ``# Return original MSB after shifting.``    ``# n now becomes 100000000``    ``return` `(n >> ``1``)``  ` `# This code is contributed by akashish__`

C#

 `using` `System;` `public` `class` `GFG{``  ` `  ``public` `static` `int` `setBitNumber(``int` `n)``{``    ``// Below steps set bits after``    ``// MSB (including MSB)` `    ``// Suppose n is 273 (binary``    ``// is 100010001). It does following``    ``// 100010001 | 010001000 = 110011001``    ``n |= n >> 1;` `    ``// This makes sure 4 bits``    ``// (From MSB and including MSB)``    ``// are set. It does following``    ``// 110011001 | 001100110 = 111111111``    ``n |= n >> 2;` `    ``n |= n >> 4;``    ``n |= n >> 8;``    ``n |= n >> 16;` `    ``// Increment n by 1 so that``    ``// there is only one set bit``    ``// which is just before original``    ``// MSB. n now becomes 1000000000``    ``n = n + 1;` `    ``// Return original MSB after shifting.``    ``// n now becomes 100000000``    ``return` `(n >> 1);``}` `    ``static` `public` `void` `Main (){` `        ``// Code``    ``}``}` `// This code is contributed by akashish__`

Javascript

 `function` `setBitNumber(n)``{``    ``// Below steps set bits after``    ``// MSB (including MSB)` `    ``// Suppose n is 273 (binary``    ``// is 100010001). It does following``    ``// 100010001 | 010001000 = 110011001``    ``n |= n >> 1;` `    ``// This makes sure 4 bits``    ``// (From MSB and including MSB)``    ``// are set. It does following``    ``// 110011001 | 001100110 = 111111111``    ``n |= n >> 2;` `    ``n |= n >> 4;``    ``n |= n >> 8;``    ``n |= n >> 16;` `    ``// Increment n by 1 so that``    ``// there is only one set bit``    ``// which is just before original``    ``// MSB. n now becomes 1000000000``    ``n = n + 1;` `    ``// Return original MSB after shifting.``    ``// n now becomes 100000000``    ``return` `(n >> 1);``}` `// This code is contributed by akashish__`

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

Refer Find most significant set bit of a number for details.

10. Check if a number has bits in an alternate pattern

We can quickly check if bits in a number are in an alternate pattern (like 101010).

Compute bitwise XOR (XOR denoted using ^) of n and (n >> 1). If n has an alternate pattern, then n ^ (n >> 1) operation will produce a number having all bits set.

Below is the implementation of the above approach.

C++

 `// function to check if all the bits``// are set or not in the binary``// representation of 'n'``static` `bool` `allBitsAreSet(``int` `n)``{``    ``// if true, then all bits are set``    ``if` `(((n + 1) & n) == 0)``        ``return` `true``;` `    ``// else all bits are not set``    ``return` `false``;``}` `// Function to check if a number``// has bits in alternate pattern``bool` `bitsAreInAltOrder(unsigned ``int` `n)``{``    ``unsigned ``int` `num = n ^ (n >> 1);` `    ``// To check if all bits are set in 'num'``    ``return` `allBitsAreSet(num);``}`

Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {` `  ``// function to check if all the bits``  ``// are set or not in the binary``  ``// representation of 'n'``  ``public` `static` `boolean` `allBitsAreSet(``long` `n)``  ``{` `    ``// if true, then all bits are set``    ``if` `(((n + ``1``) & n) == ``0``)``      ``return` `true``;` `    ``// else all bits are not set``    ``return` `false``;``  ``}` `  ``// Function to check if a number``  ``// has bits in alternate pattern``  ``public` `static` `boolean` `bitsAreInAltOrder(``long` `n)``  ``{``    ``long` `num = n ^ (n >> ``1``);` `    ``// To check if all bits are set in 'num'``    ``return` `allBitsAreSet(num);``  ``}``  ``public` `static` `void` `main (String[] args) {` `  ``}``}` `// This code is contributed by akashish__`

Python3

 `# function to check if all the bits``# are set or not in the binary``# representation of 'n'``def` `allBitsAreSet(n):``  ``# if true, then all bits are set``  ``if` `(((n ``+` `1``) & n) ``=``=` `0``):``    ``return` `True` `  ``# else all bits are not set``  ``return` `False` `# Function to check if a number``# has bits in alternate pattern``def` `bitsAreInAltOrder(n):``  ``num ``=` `n ^ (n >> ``1``)` `  ``# To check if all bits are set in 'num'``  ``return` `allBitsAreSet(num)`  `# This code is contributed by akashish__`

C#

 `using` `System;``public` `class` `GFG``{` `    ``// function to check if all the bits``    ``// are set or not in the binary``    ``// representation of 'n'``    ``public` `static` `bool` `allBitsAreSet(``uint` `n)``    ``{``      ` `        ``// if true, then all bits are set``        ``if` `(((n + 1) & n) == 0)``            ``return` `true``;` `        ``// else all bits are not set``        ``return` `false``;``    ``}` `    ``// Function to check if a number``    ``// has bits in alternate pattern``    ``public` `static` `bool` `bitsAreInAltOrder(``uint` `n)``    ``{``        ``uint` `num = n ^ (n >> 1);` `        ``// To check if all bits are set in 'num'``        ``return` `allBitsAreSet(num);``    ``}` `    ``static` `public` `void` `Main() {}``}` `// This code is contributed by akashish__`

Javascript

 `// function to check if all the bits``// are set or not in the binary``// representation of 'n'``function` `allBitsAreSet(n)``{``    ``// if true, then all bits are set``    ``if` `(((n + 1) & n) == 0)``        ``return` `true``;` `    ``// else all bits are not set``    ``return` `false``;``}` `// Function to check if a number``// has bits in alternate pattern``function` `bitsAreInAltOrder(n)``{``    ``let num = n ^ (n >> 1);` `    ``// To check if all bits are set in 'num'``    ``return` `allBitsAreSet(num);``}` `// This code is contributed by akashish__`

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

Refer check if a number has bits in alternate pattern for details.

DSA Self Paced Course

This article is contributed by Sanchit Garg 1. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.