Swap two nibbles in a byte

10 Jun, 2022
A nibble is a four-bit aggregation, or half an octet. There are two nibbles in a byte. Given a byte, swap the two nibbles in it. For example 100 is be represented as 01100100 in a byte (or 8 bits). The two nibbles are (0110) and (0100). If we swap the two nibbles, we get 01000110 which is 70 in decimal. 
To swap the nibbles, we can use bitwise &, bitwise ” operators. A byte can be represented using a unsigned char in C as size of char is 1 byte in a typical C compiler. Below is the implementation of above idea.  
C++
C
Java
Python3
C#
PHP
Javascript
// C++ program to swap two// nibbles in a byte#include <bits/stdc++.h>using namespace std; int swapNibbles(int x){    return ( (x & 0x0F) << 4 | (x & 0xF0) >> 4 );} // Driver codeint main(){    int x = 100;    cout << swapNibbles(x);    return 0;} //This code is contributed by Shivi_Aggarwal
#include <stdio.h> unsigned char swapNibbles(unsigned char x){    return ( (x & 0x0F)<<4 | (x & 0xF0)>>4 );} int main(){    unsigned char x = 100;    printf("%u", swapNibbles(x));    return 0;}
// Java program to swap two// nibbles in a byte class GFG {     static int swapNibbles(int x){    return ((x & 0x0F) << 4 | (x & 0xF0) >> 4);} // Driver codepublic static void main(String arg[]){    int x = 100;    System.out.print(swapNibbles(x));}} // This code is contributed by Anant Agarwal.
# python program Swap# two nibbles in a byte def swapNibbles(x):    return ( (x & 0x0F)<<4 | (x & 0xF0)>>4 ) # Driver code x = 100print(swapNibbles(x)) # This code is contributed# by Anant Agarwal.
// C# program to swap two// nibbles in a byteusing System; class GFG { // Function for swapping   static int swapNibbles(int x){    return ((x & 0x0F) << 4 |            (x & 0xF0) >> 4);} // Driver codepublic static void Main(){    int x = 100;    Console.Write(swapNibbles(x));}} // This code is contributed by Nitin Mittal.
<?php// PHP program to swap two// nibbles in a byte // function to Swap two nibbles// in a byte in php programfunction swapNibbles($x){    return ( ($x & 0x0F) << 4 |           ($x & 0xF0) >> 4 );}     // Driver Code    $x = 100;    echo swapNibbles($x); // This Code is Contributed by Ajit?>
<script>// javascript program to swap two// nibbles in a byte  function swapNibbles(x){    return ((x & 0x0F) << 4 | (x & 0xF0) >> 4);} // Driver codevar x = 100;document.write(swapNibbles(x)); // This code is contributed by Princi Singh</script>
70
Explanation: 100 is 01100100 in binary. The operation can be split mainly in two parts 1) The expression “x & 0x0F” gives us last 4 bits of x. For x = 100, the result is 00000100. Using bitwise ‘<<‘ operator, we shift the last four bits to the left 4 times and make the new last four bits as 0. The result after shift is 01000000.2) The expression “x & 0xF0” gives us first four bits of x. For x = 100, the result is 01100000. Using bitwise ‘>>’ operator, we shift the digit to the right 4 times and make the first four bits as 0. The result after shift is 00000110.At the end we use the bitwise OR ‘|’ operation of the two expressions explained above. The OR operator places first nibble to the end and last nibble to first. For x = 100, the value of (01000000) OR (00000110) gives the result 01000110 which is equal to 70 in decimal.This article is contributed by Anuj Garg. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Another Approach:
Using binary instead of hexadecimal values. It is much clearer to beginners.
Step 1: Take & of 00001111 with number to get right nibble i.e. 0b00001111 & N
Step 2: Take & of 11110000 with number to get left nibble i.e. 0b11110000 & N
Step 3: Left shift the right nibble obtained in step 1 by 4 positions to get it as left nibble in the final answer i.e. <<4
Step 4: Right shift the left nibble obtained in step 2 by 4 positions to get it as right nibble in final answer >>4
Step 5: Do or( | ) operation between values obtained in step 3 & 4 to get the answer
C++
Java
Python3
C#
Javascript
// C++ program to swap two// nibbles in a byte#include <bits/stdc++.h>using namespace std;  int swapNibbles(int N) {      // Step 1        int right = (N & 0b00001111);      // Step 3        right= (right<<4);      // Step 2        int left = (N & 0b11110000);      // Step 4        left = (left>>4);      // Step 5        return (right | left);    } // Driver codeint main(){    int n = 100;    cout << "Original: " << n << " Swapped: " << swapNibbles(n);             return 0;} // This code is contributed by sanjoy_62.
/*package whatever //do not write package name here */ import java.io.*;class Solution{    static int swapNibbles(int N) {      // Step 1        int right = (N & 0b00001111);      // Step 3        right= (right<<4);      // Step 2        int left = (N & 0b11110000);      // Step 4        left = (left>>4);      // Step 5        return (right | left);    }}class GFG {    public static void main (String[] args) {      Solution s = new Solution();      int n = 100;        System.out.println("Original: "+ n + " Swapped: " + s.swapNibbles(n));    }}
# Python code for the above approachfrom math import ceil, sqrt def swapNibbles(N) :         # Step 1    right = (N & 0b00001111)         # Step 3    right= (right<<4)         # Step 2    left = (N & 0b11110000)           # Step 4    left = (left>>4)         # Step 5    return (right | left) # Driver Coden = 100;print("Original: ", n, end = " ")print(" Swapped: " , swapNibbles(n)) # This code is contributed by code_hunt.
// C# program to swap two// nibbles in a byteusing System; public class GFG{   static int swapNibbles(int N) {    // Step 1    int right = (N & 0b00001111);    // Step 3    right= (right<<4);    // Step 2    int left = (N & 0b11110000);    // Step 4    left = (left>>4);    // Step 5    return (right | left);  }   // Driver Code  static public void Main (){    int n = 100;    Console.Write("Original: "+ n + " Swapped: " + swapNibbles(n));  }} // This code is contributed by shruti456rawal
// JavaScript code for the above approachfunction swapNibbles(N){         // Step 1    var right = (N & 0b00001111);         // Step 3    var right= (right<<4);         // Step 2    var left = (N & 0b11110000);           // Step 4    var left = (left>>4);         // Step 5    return (right | left); } // Driver Codevar n = 100;console.log("Original:", n, " Swapped:", swapNibbles(n)); // This code is contributed by phasing17
Original: 100 Swapped: 70
This article is contributed by Arvind Bakshi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
nitin mittal
jit_t
Shivi_Aggarwal
princi singh
Abcool
sanjoy_62
code_hunt
shruti456rawal
phasing17
Accolite
Qualcomm
Samsung
Bit Magic
Accolite
Samsung
Qualcomm
Bit Magic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Little and Big Endian Mystery
Program to find whether a given number is power of 2
Binary representation of a given number
Josephus problem | Set 1 (A O(n) Solution)
Bit Fields in C
Divide two integers without using multiplication, division and mod operator
Find the element that appears once
Add two numbers without using arithmetic operators
C++ bitset and its application
Set, Clear and Toggle a given bit of a number in C