# 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.

Recommended Practice

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++

 `// C++ program to swap two` `// nibbles in a byte` `#include ` `using` `namespace` `std;`   `int` `swapNibbles(``int` `x)` `{` `    ``return` `( (x & 0x0F) << 4 | (x & 0xF0) >> 4 );` `}`   `// Driver code` `int` `main()` `{` `    ``int` `x = 100;` `    ``cout << swapNibbles(x);` `    ``return` `0;` `}`   `//This code is contributed by Shivi_Aggarwal`

## C

 `#include `   `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

 `// Java program to swap two` `// nibbles in a byte`   `class` `GFG {` `    `  `static` `int` `swapNibbles(``int` `x)` `{` `    ``return` `((x & ``0x0F``) << ``4` `| (x & ``0xF0``) >> ``4``);` `}`   `// Driver code` `public` `static` `void` `main(String arg[])` `{` `    ``int` `x = ``100``;` `    ``System.out.print(swapNibbles(x));` `}` `}`   `// This code is contributed by Anant Agarwal.`

## Python3

 `# python program Swap` `# two nibbles in a byte`   `def` `swapNibbles(x):` `    ``return` `( (x & ``0x0F``)<<``4` `| (x & ``0xF0``)>>``4` `)`   `# Driver code`   `x ``=` `100` `print``(swapNibbles(x))`   `# This code is contributed` `# by Anant Agarwal.`

## C#

 `// C# program to swap two` `// nibbles in a byte` `using` `System;`   `class` `GFG {`   `// Function for swapping    ` `static` `int` `swapNibbles(``int` `x)` `{` `    ``return` `((x & 0x0F) << 4 | ` `            ``(x & 0xF0) >> 4);` `}`   `// Driver code` `public` `static` `void` `Main()` `{` `    ``int` `x = 100;` `    ``Console.Write(swapNibbles(x));` `}` `}`   `// This code is contributed by Nitin Mittal.`

## PHP

 `> 4 );` `}`   `    ``// Driver Code` `    ``\$x` `= 100;` `    ``echo` `swapNibbles(``\$x``);`   `// This Code is Contributed by Ajit` `?>`

## Javascript

 ``

Output

`70`

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.

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++

 `// C++ program to swap two` `// nibbles in a byte` `#include ` `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 code` `int` `main()` `{` `    ``int` `n = 100;` `    ``cout << ``"Original: "` `<< n << ``" Swapped: "` `<< swapNibbles(n);` `        `  `    ``return` `0;` `}`   `// This code is contributed by sanjoy_62.`

## Java

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

## Python3

 `# Python code for the above approach` `from` `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 Code` `n ``=` `100``;` `print``(``"Original: "``, n, end ``=` `" "``)` `print``(``" Swapped: "` `, swapNibbles(n))`   `# This code is contributed by code_hunt.`

## C#

 `// C# program to swap two` `// nibbles in a byte` `using` `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

 `// JavaScript code for the above approach` `function` `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 Code` `var` `n = 100;` `console.log(``"Original:"``, n, ``" Swapped:"``, swapNibbles(n));`   `// This code is contributed by phasing17`

Output

`Original: 100 Swapped: 70`

Time Complexity: O(1)
Auxiliary Space: O(1)