Swap two nibbles in a byte
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 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.
Method 1: To swap the nibbles, we can use bitwise &, bitwise ” operators. A byte can be represented using an unsigned char in C as size of char is 1 byte in a typical C compiler.
Below is the implementation of the above idea.
C++
#include <bits/stdc++.h>
using namespace std;
int swapNibbles( int x)
{
return ( (x & 0x0F) << 4 | (x & 0xF0) >> 4 );
}
int main()
{
int x = 100;
cout << swapNibbles(x);
return 0;
}
|
C
#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
class GFG {
static int swapNibbles( int x)
{
return ((x & 0x0F ) << 4 | (x & 0xF0 ) >> 4 );
}
public static void main(String arg[])
{
int x = 100 ;
System.out.print(swapNibbles(x));
}
}
|
Python3
def swapNibbles(x):
return ( (x & 0x0F )<< 4 | (x & 0xF0 )>> 4 )
x = 100
print (swapNibbles(x))
|
C#
using System;
class GFG {
static int swapNibbles( int x)
{
return ((x & 0x0F) << 4 |
(x & 0xF0) >> 4);
}
public static void Main()
{
int x = 100;
Console.Write(swapNibbles(x));
}
}
|
PHP
<?php
function swapNibbles( $x )
{
return ( ( $x & 0x0F) << 4 |
( $x & 0xF0) >> 4 );
}
$x = 100;
echo swapNibbles( $x );
?>
|
Javascript
<script>
function swapNibbles(x)
{
return ((x & 0x0F) << 4 | (x & 0xF0) >> 4);
}
var x = 100;
document.write(swapNibbles(x));
</script>
|
Time Complexity: O(1)
Auxiliary Space: O(1)
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.
/p>
Another Approach:
Using binary instead of hexadecimal values. It is much clearer to beginners.
- Take & of 00001111 with number to get right nibble i.e. 0b00001111 & N
- ake & of 11110000 with number to get left nibble i.e. 0b11110000 & N
- 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
- Right shift the left nibble obtained in step 2 by 4 positions to get it as right nibble in final answer >>4
- Do or( | ) operation between values obtained in step 3 & 4 to get the answer
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int swapNibbles( int N) {
int right = (N & 0b00001111);
right= (right<<4);
int left = (N & 0b11110000);
left = (left>>4);
return (right | left);
}
int main()
{
int n = 100;
cout << "Original: " << n << " Swapped: " << swapNibbles(n);
return 0;
}
|
Java
import java.io.*;
class Solution{
static int swapNibbles( int N) {
int right = (N & 0b00001111);
right= (right<< 4 );
int left = (N & 0b11110000);
left = (left>> 4 );
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));
}
}
|
Python3
from math import ceil, sqrt
def swapNibbles(N) :
right = (N & 0b00001111 )
right = (right<< 4 )
left = (N & 0b11110000 )
left = (left>> 4 )
return (right | left)
n = 100 ;
print ( "Original: " , n, end = " " )
print ( " Swapped: " , swapNibbles(n))
|
C#
using System;
public class GFG{
static int swapNibbles( int N) {
int right = (N & 0b00001111);
right= (right<<4);
int left = (N & 0b11110000);
left = (left>>4);
return (right | left);
}
static public void Main (){
int n = 100;
Console.Write( "Original: " + n + " Swapped: " + swapNibbles(n));
}
}
|
Javascript
function swapNibbles(N)
{
var right = (N & 0b00001111);
var right= (right<<4);
var left = (N & 0b11110000);
var left = (left>>4);
return (right | left);
}
var n = 100;
console.log( "Original:" , n, " Swapped:" , swapNibbles(n));
|
Output
Original: 100 Swapped: 70
Time Complexity: O(1)
Auxiliary Space: O(1)
Last Updated :
29 Dec, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...