Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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 <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.
?>
Javascript



<script>
 
// Javascript Program to swap bits
// in a given number
 
 
    function  swapBits(x, p1, p2, n)
    {
        // Move all bits of first set
        // to rightmost side
        let set1 = (x >> p1) & ((1 << n) - 1);
 
        // Move all bits of second set
        // to rightmost side
        let set2 = (x >> p2) & ((1 << n) - 1);
 
        // XOR the two sets
        let 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
        let result = x ^ xor;
 
        return result;
    }
 
// Driver Code
 
    let res = swapBits(28, 0, 3, 2);
    document.write("Result = " + res);
 
</script>
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 <iostream>
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



<script>
 
function swapBits(num, p1, p2, n)
{
    let 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
let res = swapBits(28, 0, 3, 2);
 
document.write("Result = " + res);
 
// This code is contributed by suresh07
     
</script>
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
Previous
Swap every two bits in bytes
Next

How to swap two bits in a given integer?
Recommended Articles
Page :
Swap all odd and even bits
06, Mar 13
How to swap two bits in a given integer?
27, Jun 15
Swap every two bits in bytes
30, Jan 18
Check if bits of a number has count of consecutive set bits in increasing order
12, Jan 17
Toggle bits of a number except first and last bits
14, Jan 18
Bit manipulation | Swap Endianness of a number
30, Jul 19
Number of ways to swap two bit of s1 so that bitwise OR of s1 and s2 changes
26, Nov 18
Maximize a given unsigned number number by swapping bits at it's extreme positions.
18, Jul 17
Find the largest number smaller than integer N with maximum number of set bits
26, Apr 20
Check if a number has same number of set and unset bits
30, Jul 18
Same Number Of Set Bits As N
29, May 18
Set all even bits of a number
22, Jan 18
Set all odd bits of a number
19, Jan 18
Check whether the number has only first and last bits set
30, Sep 17
For every set bit of a number toggle bits of other
17, Jan 18
Set all the bits in given range of a number
19, Sep 17
Toggle all the bits of a number except k-th bit.
01, Jun 17
Toggle all odd bits of a number
11, Dec 17
Largest number less than X having at most K set bits
07, Jan 19
Toggle all even bits of a number
11, Jan 18
Flip all K-bits of a given number
19, Jan 21
Toggle first and last bits of a number
11, Jan 18
Change all even bits in a number to 0
15, Aug 17
Check if all bits of a number are set
27, Jun 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox