# Swap bits in a given number

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.

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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. ` `?> `

Output:

``` Result = 7
```

Following is a shorter implementation of the same logic

 `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

 `#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 positon 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; ` `} `

Output:

``` Result = 7
```

References:
Swapping individual bits with XOR

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.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

12

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.