Intercambiar dos nibbles en un byte

Un nibble es una agregación de cuatro bits, o medio octeto. Hay dos nibbles en un byte. 
Dado un byte, intercambie los dos nibbles que contiene. Por ejemplo, 100 se representa como 01100100 en un byte (u 8 bits). Los dos nibbles son (0110) y (0100). Si intercambiamos los dos nibbles, obtenemos 01000110 que es 70 en decimal.
 

Para intercambiar los nibbles, podemos usar los operadores bit a bit &, bit a bit ”. Un byte se puede representar utilizando un carácter sin firmar en C, ya que el tamaño del carácter es de 1 byte en un compilador típico de C. 
A continuación se muestra la implementación de la idea anterior. 
 

// 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 code
int 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 code
public 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 = 100
print(swapNibbles(x))
 
# This code is contributed
# by Anant Agarwal.

// 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
// PHP program to swap two
// nibbles in a byte
 
// function to Swap two nibbles
// in a byte in php program
function 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 code
var x = 100;
document.write(swapNibbles(x));
 
// This code is contributed by Princi Singh
</script>

70

Explicación: 
100 es 01100100 en binario. La operación se puede dividir principalmente en dos partes 
1) La expresión “ x & 0x0F ” nos da los últimos 4 bits de x. Para x = 100, el resultado es 00000100. Usando el operador bit a bit ‘<<‘, desplazamos los últimos cuatro bits a la izquierda 4 veces y convertimos los nuevos últimos cuatro bits en 0. El resultado después del desplazamiento es 01000000.
2) La expresión “ x & 0xF0 ” nos da los primeros cuatro bits de x. Para x = 100, el resultado es 01100000. Usando el operador bit a bit ‘>>’, desplazamos el dígito a la derecha 4 veces y convertimos los primeros cuatro bits en 0. El resultado después del desplazamiento es 00000110.
Al final usamos el OR bit a bit ‘|’ funcionamiento de las dos expresiones explicadas anteriormente. El operador OR coloca el primer nibble al final y el último al primero. Para x = 100, el valor de (01000000) OR (00000110) da como resultado 01000110 que es igual a 70 en decimal.
Este artículo es una contribución de Anuj Garg . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Otro enfoque:

Usar valores binarios en lugar de hexadecimales. Es mucho más claro para los principiantes.

Paso 1: Tome & de 00001111 con el número para obtener el mordisco correcto, es decir, 0b00001111 & N

Paso 2: Tome & de 11110000 con el número para obtener el nibble izquierdo, es decir, 0b11110000 & N

Paso 3: Desplace a la izquierda el nibble derecho obtenido en el paso 1 en 4 posiciones para obtenerlo como nibble izquierdo en la respuesta final, es decir <<4

Paso 4: Desplace a la derecha el nibble izquierdo obtenido en el paso 2 en 4 posiciones para obtenerlo como nibble derecho en la respuesta final >>4

Paso 5: Realice la operación o ( | ) entre los valores obtenidos en los pasos 3 y 4 para obtener la respuesta

// 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 code
int 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 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# 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 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

Original: 100 Swapped: 70

Este artículo es una contribución de Arvind Bakshi . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.