# Swap bits in a given number

Given a number x and two positions (from right side) in 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.

Let p1 and p2 be the two given positions.

Example 1
Input:
x = 47 (00101111)
p1 = 1 (Start from second bit from right side)
p2 = 5 (Start from 6th bit from right side)
n = 3 (No of bits to be swapped)
Output:
227 (11100011)
The 3 bits starting from the second bit (from right side) are
swapped with 3 bits starting from 6th position (from 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 postion (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 first set to 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:

```#include<stdio.h>

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);

/* Moce 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;
}

/* Drier program to test above function*/
int main()
{
int res =  swapBits(28, 0, 3, 2);
printf("\nResult = %d ", res);
return 0;
}
```

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));
}
```

References:
Swapping individual bits with XOR

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.9 Average Difficulty : 3.9/5.0
Based on 50 vote(s)