Introduzione
Manipolazione dei bit
Java ha degli operatori per manipolare i bit di un byte, short, int, long o char.
Operatori di shift
Usa << per spostare i bit a sinistra e >> per spostarli a destra.
// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100
// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010
L'operatore << inserisce sempre degli 0 sul lato destro.
L'operatore >>, invece, inserisce lo stesso bit del bit più a sinistra (1 se il numero è negativo, 0 se è 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 >>> quando, spostando a destra, devono essere inseriti degli 0.
// Shift two places to the right, inserting 0s on the left
value >>> 2;
// # => 0010_0000_0000_0000_0000_0000_0000_1001
Operazioni bit a bit
AND bit a bit
L'operatore AND bit a bit (&) prende due valori ed esegue un AND su ogni bit.
Confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore.
Se entrambi sono 1, il bit del risultato è 1.
Altrimenti, il bit del risultato è 0.
0b0110_0101 & 0b0011_1100;
// # => 0b0010_0100
OR bit a bit
L'operatore OR bit a bit (|) prende due valori ed esegue un OR su ogni bit.
Confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore.
Se almeno uno dei due bit è 1, il bit del risultato è 1.
Altrimenti è 0.
0b0110_0101 | 0b0011_1100;
// # => 0b0111_1101
XOR bit a bit
L'operatore XOR bit a bit (^) esegue un XOR bit a bit su due valori.
Come gli operatori AND bit a bit e OR bit a bit, confronta ogni bit del primo valore con il bit nella stessa posizione del secondo valore.
Se solo uno dei due è 1, il bit risultante è 1.
Altrimenti è 0.
0b0110_0101 ^ 0b0011_1100;
// # => 0b0101_1001
NOT bit a bit(~)
Infine, l'operatore NOT bit a bit (~) inverte ogni bit.
A differenza degli operatori precedenti, questo è un operatore unario e agisce su un solo valore.
~0b0110_0101;
// # => 0b1001_1010
Istruzioni
Un tuo amico ti ha appena inviato un messaggio con un segreto importante.
Per non rendere troppo facile leggerlo agli altri, il messaggio è stato cifrato eseguendo una serie di manipolazioni sui bit.
Dovrai scrivere i metodi che servono a decifrare il messaggio.
1. Sposta i bit indietro
Il primo passo per decifrare il messaggio consiste nell'annullare lo scorrimento fatto durante la cifratura, spostando di nuovo i bit verso destra.
Nei passaggi successivi del processo di decifratura si presume che vengano inseriti degli 0 dal lato sinistro.
Implementa il metodo Secrets.shiftBack, che accetta un valore e il numero di posizioni da spostare ed esegue lo scorrimento.
Secrets.shiftBack(0b1001, 2);
# => 0b0010
2. Imposta alcuni bit
Ora ci sono alcuni bit che devono essere impostati a 1.
Implementa il metodo Secrets.setBits, che accetta un valore e una maschera e restituisce il risultato dell'impostazione a 1 dei bit di value.
Un bit di value va impostato a 1 dove anche il bit della maschera è 1.
Tutti gli altri bit devono restare invariati.
Secrets.setBits(0b0110, 0b0101);
# => 0b0111
3. Inverti bit specifici
Durante la cifratura alcuni bit vengono invertiti.
Per decifrare il messaggio bisognerà invertirli di nuovo.
Implementa il metodo Secrets.flipBits, che accetta un valore e la maschera.
La maschera indica quali bit del valore invertire.
Se il bit è 1 nella maschera, il bit viene invertito nel valore.
Tutti gli altri bit restano invariati.
Secrets.flipBits(0b1100, 0b0101);
# => 0b1001
4. Azzera bit specifici
Infine, ci sono anche alcuni bit che, una volta decifrati, valgono sempre 0.
Implementa il metodo Secrets.clearBits, che accetta un valore e una maschera.
I bit di value vanno impostati a 0 dove il bit della maschera è 1.
Tutti gli altri bit devono restare invariati.
Secrets.clearBits(0b0110, 0b0101);
# => 0b0010
Esercizio di apprendimento
