Introduction
Manipulation de bits
Java fournit des opérateurs pour manipuler les bits d'un byte, short, int, long ou char.
Opérateurs de décalage
Utilise << pour décaler les bits vers la gauche et >> pour les décaler vers la droite.
// Shift two places to the left
0b0000_1011 << 2;
// # => 0b0010_1100
// Shift two places to the right
0b0000_1011 >> 2;
// # => 0b0000_0010
L'opérateur << insère toujours des 0 du côté droit.
En revanche, >> insère le même bit que le bit le plus à gauche (1 si le nombre est négatif, 0 s'il est positif).
// 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
Utilise plutôt >>> quand il faut insérer des 0 lors d'un décalage vers la droite.
// Shift two places to the right, inserting 0s on the left
value >>> 2;
// # => 0010_0000_0000_0000_0000_0000_0000_1001
Opérations bit à bit
ET bit à bit
L'opérateur ET bit à bit (&) prend deux valeurs et effectue un ET sur chaque bit.
Il compare chaque bit de la première valeur avec le bit situé à la même position dans la seconde valeur.
Si les deux bits valent 1, le bit du résultat vaut 1.
Sinon, le bit du résultat vaut 0.
0b0110_0101 & 0b0011_1100;
// # => 0b0010_0100
OU bit à bit
L'opérateur OU bit à bit (|) prend deux valeurs et effectue un OU sur chaque bit.
Il compare chaque bit de la première valeur avec le bit situé à la même position dans la seconde valeur.
Si l'un des deux bits vaut 1, le bit du résultat vaut 1.
Sinon, il vaut 0.
0b0110_0101 | 0b0011_1100;
// # => 0b0111_1101
OU exclusif bit à bit
L'opérateur OU exclusif bit à bit (^) effectue un OU exclusif bit à bit sur deux valeurs.
Comme les opérateurs ET bit à bit et OU bit à bit, il compare chaque bit de la première valeur avec le bit situé à la même position dans la seconde valeur.
Si un seul des deux vaut 1, le bit obtenu vaut 1.
Sinon, il vaut 0.
0b0110_0101 ^ 0b0011_1100;
// # => 0b0101_1001
NON bit à bit (~)
Enfin, l'opérateur NON bit à bit (~) inverse chaque bit.
Contrairement aux opérateurs précédents, il s'agit d'un opérateur unaire, qui n'agit que sur une seule valeur.
~0b0110_0101;
// # => 0b1001_1010
Instructions
Un ami vient de t'envoyer un message contenant un secret important.
Comme il ne voulait pas que d'autres puissent le lire facilement, le message a été chiffré en effectuant une série de manipulations de bits.
Tu vas devoir écrire les méthodes qui permettront de déchiffrer le message.
1. Redécale les bits
La première étape du déchiffrement consiste à annuler le décalage effectué lors du chiffrement, en redécalant les bits vers la droite.
Les étapes suivantes du déchiffrement supposent que des 0 sont insérés par la gauche.
Implémente la méthode Secrets.shiftBack qui prend une valeur et le nombre de positions à décaler, et effectue le décalage.
Secrets.shiftBack(0b1001, 2);
# => 0b0010
2. Active certains bits
Ensuite, certains bits doivent être mis à 1.
Implémente la méthode Secrets.setBits qui prend une valeur et un masque et renvoie le résultat de la mise à 1 des bits de la valeur.
Un bit de la valeur doit être mis à 1 lorsque le bit correspondant du masque vaut aussi 1.
Tous les autres bits doivent rester inchangés.
Secrets.setBits(0b0110, 0b0101);
# => 0b0111
3. Inverse des bits précis
Certains bits sont inversés lors du chiffrement.
Il faudra les inverser à nouveau pour déchiffrer le message.
Implémente la méthode Secrets.flipBits qui prend une valeur et le masque.
Le masque indique quels bits de la valeur doivent être inversés.
Si un bit du masque vaut 1, le bit correspondant de la valeur est inversé.
Tous les autres bits restent inchangés.
Secrets.flipBits(0b1100, 0b0101);
# => 0b1001
4. Efface des bits précis
Enfin, il y a aussi certains bits qui donnent toujours 0 après déchiffrement.
Implémente la méthode Secrets.clearBits qui prend une valeur et un masque.
Les bits de value doivent être mis à 0 lorsque le bit correspondant du masque vaut 1.
Tous les autres bits doivent rester inchangés.
Secrets.clearBits(0b0110, 0b0101);
# => 0b0010
Exercice d'apprentissage
