Skip to content
Related Articles
Swap bits in a given number
• Difficulty Level : Hard
• Last Updated : 29 Apr, 2021

Given a number x and two positions (from the right side) in the binary representation of x, write a function that swaps n bits at given two positions and returns the result. It is also given that the two sets of bits do not overlap.

Method 1
Let p1 and p2 be the two given positions.

Example 1

```Input:
x = 47 (00101111)
p1 = 1 (Start from the second bit from the right side)
p2 = 5 (Start from the 6th bit from the right side)
n = 3 (No of bits to be swapped)
Output:
227 (11100011)
The 3 bits starting from the second bit (from the right side) are
swapped with 3 bits starting from 6th position (from the right side)```

Example 2

```Input:
x = 28 (11100)
p1 = 0 (Start from first bit from right side)
p2 = 3 (Start from 4th bit from right side)
n = 2 (No of bits to be swapped)
Output:
7 (00111)
The 2 bits starting from 0th position (from right side) are
swapped with 2 bits starting from 4th position (from right side)```

Solution
We need to swap two sets of bits. XOR can be used in a similar way as it is used to swap 2 numbers. Following is the algorithm.

```1) Move all bits of the first set to the rightmost side
set1 =  (x >> p1) & ((1U << n) - 1)
Here the expression (1U << n) - 1 gives a number that
contains last n bits set and other bits as 0. We do &
with this expression so that bits other than the last
n bits become 0.
2) Move all bits of second set to rightmost side
set2 =  (x >> p2) & ((1U << n) - 1)
3) XOR the two sets of bits
xor = (set1 ^ set2)
4) Put the xor bits back to their original positions.
xor = (xor << p1) | (xor << p2)
5) Finally, XOR the xor with original number so
that the two sets are swapped.
result = x ^ xor```

Implementation:

## C++

 `// C++ Program to swap bits``// in a given number``#include ``using` `namespace` `std;` `int` `swapBits(unsigned ``int` `x, unsigned ``int` `p1,``             ``unsigned ``int` `p2, unsigned ``int` `n)``{``    ``/* Move all bits of first set to rightmost side */``    ``unsigned ``int` `set1 = (x >> p1) & ((1U << n) - 1);` `    ``/* Move all bits of second set to rightmost side */``    ``unsigned ``int` `set2 = (x >> p2) & ((1U << n) - 1);` `    ``/* Xor the two sets */``    ``unsigned ``int` `Xor = (set1 ^ set2);` `    ``/* Put the Xor bits back to their original positions */``    ``Xor = (Xor << p1) | (Xor << p2);` `    ``/* Xor the 'Xor' with the original number so that the``    ``two sets are swapped */``    ``unsigned ``int` `result = x ^ Xor;` `    ``return` `result;``}` `/* Driver code*/``int` `main()``{``    ``int` `res = swapBits(28, 0, 3, 2);``    ``cout << ``"Result = "` `<< res;``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `// C Program to swap bits``// in a given number``#include ` `int` `swapBits(unsigned ``int` `x, unsigned ``int` `p1, unsigned ``int` `p2, unsigned ``int` `n)``{``    ``/* Move all bits of first set to rightmost side */``    ``unsigned ``int` `set1 = (x >> p1) & ((1U << n) - 1);` `    ``/* Move all bits of second set to rightmost side */``    ``unsigned ``int` `set2 = (x >> p2) & ((1U << n) - 1);` `    ``/* XOR the two sets */``    ``unsigned ``int` `xor = (set1 ^ set2);` `    ``/* Put the xor bits back to their original positions */``    ``xor = (xor << p1) | (xor << p2);` `    ``/* XOR the 'xor' with the original number so that the``       ``two sets are swapped */``    ``unsigned ``int` `result = x ^ xor;` `    ``return` `result;``}` `/* Driver program to test above function*/``int` `main()``{``    ``int` `res = swapBits(28, 0, 3, 2);``    ``printf``(``"\nResult = %d "``, res);``    ``return` `0;``}`

## Java

 `// Java Program to swap bits``// in a given number` `class` `GFG {` `    ``static` `int` `swapBits(``int` `x, ``int` `p1, ``int` `p2, ``int` `n)``    ``{``        ``// Move all bits of first set``        ``// to rightmost side``        ``int` `set1 = (x >> p1) & ((``1` `<< n) - ``1``);` `        ``// Move all bits of second set``        ``// to rightmost side``        ``int` `set2 = (x >> p2) & ((``1` `<< n) - ``1``);` `        ``// XOR the two sets``        ``int` `xor = (set1 ^ set2);` `        ``// Put the xor bits back to``        ``// their original positions``        ``xor = (xor << p1) | (xor << p2);` `        ``// XOR the 'xor' with the original number``        ``// so that the  two sets are swapped``        ``int` `result = x ^ xor;` `        ``return` `result;``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `res = swapBits(``28``, ``0``, ``3``, ``2``);``        ``System.out.println(``"Result = "` `+ res);``    ``}``}` `// This code is contributed by prerna saini.`

## Python3

 `# Python program to``# swap bits in a given number` `def` `swapBits(x, p1, p2, n):` `    ``# Move all bits of first``    ``# set to rightmost side``    ``set1 ``=`  `(x >> p1) & ((``1``<< n) ``-` `1``)`` ` `    ``# Moce all bits of second``    ``# set to rightmost side``    ``set2 ``=`  `(x >> p2) & ((``1` `<< n) ``-` `1``)`` ` `    ``# XOR the two sets``    ``xor ``=` `(set1 ^ set2)`` ` `    ``# Put the xor bits back``    ``# to their original positions``    ``xor ``=` `(xor << p1) | (xor << p2)`` ` `      ``# XOR the 'xor' with the``      ``# original number so that the``      ``# two sets are swapped``    ``result ``=` `x ^ xor`` ` `    ``return` `result``    ` `# Driver code` `res ``=` `swapBits(``28``, ``0``, ``3``, ``2``)``print``(``"Result ="``, res)` `# This code is contributed``# by Anant Agarwal.`

## C#

 `// C# Program to swap bits``// in a given number``using` `System;` `class` `GFG {` `    ``static` `int` `swapBits(``int` `x, ``int` `p1, ``int` `p2, ``int` `n)``    ``{``        ``// Move all bits of first``        ``// set to rightmost side``        ``int` `set1 = (x >> p1) & ((1 << n) - 1);` `        ``// Move all bits of second set``        ``// set to rightmost side``        ``int` `set2 = (x >> p2) & ((1 << n) - 1);` `        ``// XOR the two sets``        ``int` `xor = (set1 ^ set2);` `        ``// Put the xor bits back to``        ``// their original positions``        ``xor = (xor << p1) | (xor << p2);` `        ``// XOR the 'xor' with the original number``        ``// so that the two sets are swapped``        ``int` `result = x ^ xor;` `        ``return` `result;``    ``}` `    ``// Driver program``    ``public` `static` `void` `Main()``    ``{``        ``int` `res = swapBits(28, 0, 3, 2);``        ``Console.WriteLine(``"Result = "` `+ res);``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 `> ``\$p1``) &``            ``((1 << ``\$n``) - 1);` `    ``// Move all bits of second``    ``// set to rightmost side``    ``\$set2` `= (``\$x` `>> ``\$p2``) &``            ``((1 << ``\$n``) - 1);` `    ``// XOR the two sets``    ``\$xor` `= (``\$set1` `^ ``\$set2``);` `    ``// Put the xor bits back to``    ``// their original positions``    ``\$xor` `= (``\$xor` `<< ``\$p1``) |``           ``(``\$xor` `<< ``\$p2``);` `    ``// XOR the 'xor' with the``    ``// original number so that``    ``// the two sets are swapped``    ``\$result` `= ``\$x` `^ ``\$xor``;` `    ``return` `\$result``;``}` `    ``// Driver Code``    ``\$res` `= swapBits(28, 0, 3, 2);``    ``echo` `"\nResult = "``, ``\$res``;``    ` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``

Output:

` Result = 7`

Following is a shorter implementation of the same logic

## C

 `int` `swapBits(unsigned ``int` `x, unsigned ``int` `p1, unsigned ``int` `p2, unsigned ``int` `n)``{``    ``/* xor contains xor of two sets */``    ``unsigned ``int` `xor = ((x >> p1) ^ (x >> p2)) & ((1U << n) - 1);` `    ``/* To swap two sets, we need to again XOR the xor with original sets */``    ``return` `x ^ ( (xor << p1) | (xor << p2));``}`

Method 2 –
This solution focuses on calculating the values of bits to be swapped using AND gate. Then we can set/unset those bits based on whether the bits are to be swapped. For the number of bits to be swapped (n) –

• Calculate shift1 = The value after setting bit at p1 position to 1
• Calculate shift2 = The value after setting bit at p2 position to 1
• value1 = Number to check if num at position p1 is set or not.
• value2 = Number to check if num at position p2 is set or not.
• If value1 and value2 are different is when we have to swap the bits.

Example:

```[28 0 3 2] num=28 (11100) p1=0 p2=3 n=2
Given = 11100
Required output = 00111 i.e. (00)1(11) msb 2 bits replaced with lsb 2 bits

n=2
p1=0,  p2=3
shift1= 1,  shift2= 1000
value1= 0,  value2= 1000
After swap
num= 10101

n=3
p1=1,  p2=4
shift1= 10,  shift2= 10000
value1= 0,  value2= 10000
After swap
num= 00111```

Implementation

## C++

 `#include ``using` `namespace` `std;` `int` `swapBits(unsigned ``int` `num, unsigned ``int` `p1,``             ``unsigned ``int` `p2, unsigned ``int` `n)``{``    ``int` `shift1, shift2, value1, value2;``    ``while` `(n--) {``        ``// Setting bit at p1 position to 1``        ``shift1 = 1 << p1;``        ``// Setting bit at p2 position to 1``        ``shift2 = 1 << p2;` `        ``// value1 and value2 will have 0 if num``        ``// at the respective positions - p1 and p2 is 0.``        ``value1 = ((num & shift1));``        ``value2 = ((num & shift2));` `        ``// check if value1 and value2 are different``        ``// i.e. at one position bit is set and other it is not``        ``if` `((!value1 && value2) || (!value2 && value1)) {``            ``// if bit at p1 position is set``            ``if` `(value1) {``                ``// unset bit at p1 position``                ``num = num & (~shift1);``                ``// set bit at p2 position``                ``num = num | shift2;``            ``}``            ``// if bit at p2 position is set``            ``else` `{``                ``// set bit at p2 position``                ``num = num & (~shift2);``                ``// unset bit at p2 position``                ``num = num | shift1;``            ``}``        ``}``        ``p1++;``        ``p2++;``    ``}``    ``// return final result``    ``return` `num;``}` `/* Driver code*/``int` `main()``{``    ``int` `res = swapBits(28, 0, 3, 2);``    ``cout << ``"Result = "` `<< res;``    ``return` `0;``}`

## Java

 `class` `GFG``{``    ``static` `int` `swapBits(``int` `num, ``int` `p1, ``int` `p2, ``int` `n)``    ``{``        ``int` `shift1, shift2, value1, value2;``        ``while` `(n-- > ``0``)``        ``{``          ` `            ``// Setting bit at p1 position to 1``            ``shift1 = ``1` `<< p1;``          ` `            ``// Setting bit at p2 position to 1``            ``shift2 = ``1` `<< p2;``      ` `            ``// value1 and value2 will have 0 if num``            ``// at the respective positions - p1 and p2 is 0.``            ``value1 = ((num & shift1));``            ``value2 = ((num & shift2));``      ` `            ``// check if value1 and value2 are different``            ``// i.e. at one position bit is set and other it is not``            ``if` `((value1 == ``0` `&& value2 != ``0``) ||``                ``(value2 == ``0` `&& value1 != ``0``))``            ``{``              ` `                ``// if bit at p1 position is set``                ``if` `(value1 != ``0``)``                ``{``                  ` `                    ``// unset bit at p1 position``                    ``num = num & (~shift1);``                  ` `                    ``// set bit at p2 position``                    ``num = num | shift2;``                ``}``              ` `                ``// if bit at p2 position is set``                ``else``                ``{``                  ` `                    ``// set bit at p2 position``                    ``num = num & (~shift2);``                  ` `                    ``// unset bit at p2 position``                    ``num = num | shift1;``                ``}``            ``}``            ``p1++;``            ``p2++;``        ``}``      ` `        ``// return final result``        ``return` `num;``    ``}``  ` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `res = swapBits(``28``, ``0``, ``3``, ``2``);``    ``System.out.println(``"Result = "` `+ res);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `def` `swapBits(num, p1, p2, n):``    ``shift1 ``=` `0``    ``shift2 ``=` `0``    ``value1 ``=` `0``    ``value2 ``=` `0` `    ``while``(n > ``0``):``      ` `        ``# Setting bit at p1 position to 1``        ``shift1 ``=` `1` `<< p1` `        ``# Setting bit at p2 position to 1``        ``shift2 ``=` `1` `<< p2` `        ``# value1 and value2 will have 0 if num``        ``# at the respective positions - p1 and p2 is 0.``        ``value1 ``=` `((num & shift1))``        ``value2 ``=` `((num & shift2))` `        ``# check if value1 and value2 are different``        ``# i.e. at one position bit is set and other it is not``        ``if``((value1 ``=``=` `0` `and` `value2 !``=` `0``) ``or` `(value2 ``=``=` `0` `and` `value1 !``=` `0``)):``            ` `            ``# if bit at p1 position is set``            ``if``(value1 !``=` `0``):` `                ``# unset bit at p1 position``                ``num ``=` `num & (~shift1)` `                ``# set bit at p2 position``                ``num ``=` `num | shift2` `            ``# if bit at p2 position is set``            ``else``:` `                ``# set bit at p2 position``                ``num ``=` `num & (~shift2)` `                ``# unset bit at p2 position``                ``num ``=` `num | shift1``        ``p1 ``+``=` `1``        ``p2 ``+``=` `1``        ``n ``-``=` `1` `    ``# return final result``    ``return` `num` `# Driver code``res ``=` `swapBits(``28``, ``0``, ``3``, ``2``)``print``(``"Result ="``, res)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `using` `System;``class` `GFG``{``    ` `  ``static` `int` `swapBits(``int` `num, ``int` `p1,``                      ``int` `p2, ``int` `n)``  ``{``    ``int` `shift1, shift2, value1, value2;``    ``while` `(n-- > 0)``    ``{` `      ``// Setting bit at p1 position to 1``      ``shift1 = 1 << p1;` `      ``// Setting bit at p2 position to 1``      ``shift2 = 1 << p2;` `      ``// value1 and value2 will have 0 if num``      ``// at the respective positions - p1 and p2 is 0.``      ``value1 = ((num & shift1));``      ``value2 = ((num & shift2));` `      ``// check if value1 and value2 are different``      ``// i.e. at one position bit is set and other it is not``      ``if` `((value1 == 0 && value2 != 0) || (value2 == 0 && value1 != 0))``      ``{` `        ``// if bit at p1 position is set``        ``if` `(value1 != 0)``        ``{` `          ``// unset bit at p1 position``          ``num = num & (~shift1);` `          ``// set bit at p2 position``          ``num = num | shift2;``        ``}` `        ``// if bit at p2 position is set``        ``else``        ``{` `          ``// set bit at p2 position``          ``num = num & (~shift2);` `          ``// unset bit at p2 position``          ``num = num | shift1;``        ``}``      ``}``      ``p1++;``      ``p2++;``    ``}` `    ``// return final result``    ``return` `num;``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int` `res = swapBits(28, 0, 3, 2);``    ``Console.WriteLine(``"Result = "` `+ res);``  ``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

Output:

` Result = 7`

References:
Swapping individual bits with XOR
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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 DSA Live Classes

My Personal Notes arrow_drop_up