Introducción
Manipulación de bits
Java tiene operadores para manipular los bits de un byte, short, int, long o char.
Operadores de desplazamiento
Usa << para desplazar bits a la izquierda y >> para desplazar a la derecha.
// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100
// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010
El operador << siempre inserta ceros en el lado derecho.
Sin embargo, >> inserta el mismo bit que el bit más a la izquierda (1 si el número es negativo o 0 si es positivo).
// Shift 2 places to the right preserves the sign
// This is a negative value, whose binary representation is
// 1000_0000_0000_0000_0000_0000_0010_0110
int value = -0x7FFFFFDA;
// Shift two places to the right, preserving the sign bit
value >> 2;
// # => 1110_0000_0000_0000_0000_0000_0000_1001
Usa >>> en su lugar cuando se deban insertar ceros al desplazar a la derecha.
// Shift two places to the right, inserting 0s on the left
value >>> 2;
// # => 0010_0000_0000_0000_0000_0000_0000_1001
Operaciones bit a bit
AND bit a bit
El operador AND bit a bit (&) toma dos valores y realiza una operación AND en cada bit.
Compara cada bit del primer valor con el bit en la misma posición del segundo valor.
Si ambos son 1, el bit del resultado es 1.
En caso contrario, el bit del resultado es 0.
0b0110_0101 & 0b0011_1100;
// # => 0b0010_0100
OR bit a bit
El operador OR bit a bit (|) toma dos valores y realiza una operación OR en cada bit.
Compara cada bit del primer valor con el bit en la misma posición del segundo valor.
Si alguno de los bits es 1, el bit del resultado es 1.
En caso contrario, es 0.
0b0110_0101 | 0b0011_1100;
// # => 0b0111_1101
XOR bit a bit
El operador XOR bit a bit (^) realiza una operación XOR bit a bit en dos valores.
Al igual que los operadores AND bit a bit y OR bit a bit, compara cada bit del primer valor con el bit en la misma posición del segundo valor.
Si solo uno de ellos es 1, el bit resultante es 1.
En caso contrario, es 0.
0b0110_0101 ^ 0b0011_1100;
// # => 0b0101_1001
NOT bit a bit (~)
Por último, el operador NOT bit a bit (~) invierte cada bit.
A diferencia de los operadores anteriores, este es un operador unario, que actúa solo sobre un valor.
~0b0110_0101;
// # => 0b1001_1010
Instrucciones
Tu amigo acaba de enviarte un mensaje con un secreto importante.
Como no quería que a otros les resultara fácil leerlo, el mensaje se cifró realizando una serie de manipulaciones de bits.
Tendrás que escribir los métodos que te ayuden a descifrar el mensaje.
1. Desplaza los bits de vuelta a la derecha
El primer paso para descifrar el mensaje es deshacer el desplazamiento del proceso de cifrado desplazando los bits de vuelta a la derecha.
Habrá más pasos en el proceso de descifrado que asumen que se insertan ceros desde el lado izquierdo.
Implementa el método Secrets.shiftBack que toma un valor y el número de posiciones que hay que desplazar y realiza el desplazamiento.
Secrets.shiftBack(0b1001, 2);
# => 0b0010
2. Establece algunos bits a 1
A continuación, hay algunos bits que deben establecerse a 1.
Implementa el método Secrets.setBits que toma un valor y una máscara y devuelve el resultado de establecer los bits del valor a 1.
Un bit del valor debe establecerse a 1 cuando el bit de la máscara también sea 1.
Todos los demás bits deben mantenerse sin cambios.
Secrets.setBits(0b0110, 0b0101);
# => 0b0111
3. Invierte bits específicos
Algunos bits se invierten durante el cifrado.
Habrá que invertirlos de nuevo para descifrar el mensaje.
Implementa el método Secrets.flipBits que toma un valor y la máscara.
La máscara indica qué bits del valor hay que invertir.
Si el bit es 1 en la máscara, ese bit se invierte en el valor.
Todos los demás bits se mantienen sin cambios.
Secrets.flipBits(0b1100, 0b0101);
# => 0b1001
4. Borra bits específicos
Por último, también hay ciertos bits que siempre se convierten en 0 al descifrar.
Implementa el método Secrets.clearBits que toma un valor y una máscara.
Los bits de value deben establecerse a 0 donde el bit de la máscara sea 1.
Todos los demás bits deben mantenerse sin cambios.
Secrets.clearBits(0b0110, 0b0101);
# => 0b0010
Ejercicio de aprendizaje
