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:

C

// C Program to swap bits 
// in a given number
#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);

    /* 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


<?php
// PHP Program to swap bits 
// in a given number

// function returns
// the swapped bits
function swapBits($x, $p1, $p2, $n)
{
    
    // Move all bits of first 
    // set to rightmost side 
    $set1 = ($x >> $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));
}

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.

My Personal Notes

Improved By : vt_m

Practice Tags :

Bit Magic