Introduction
Crystal dispose d'opérateurs bit à bit pour manipuler Int au niveau binaire.
Opérateurs de décalage
Crystal dispose d'opérateurs de décalage pour décaler les bits vers la gauche (<<) ou vers la droite (>>).
Décalage à gauche (<<)
L'opérateur de décalage à gauche (<<) décale les bits vers la gauche.
La valeur à décaler est indiquée à gauche et le nombre de positions de décalage à droite.
0b0010 << 1
# => 0b0100
0b0010 << 2
# => 0b1000
Si le nombre est négatif, le décalage se fait vers la droite à la place.
0b0010 << -1
# => 0b0001
Décalage à droite (>>)
L'opérateur de décalage à droite (>>) décale les bits vers la droite.
Comme pour l'opérateur de décalage à gauche, la valeur à décaler est indiquée à gauche et le nombre de positions de décalage à droite.
0b0100 >> 1
# => 0b0010
0b0100 >> 2
# => 0b0001
Et de la même manière, l'opérateur décale vers la gauche si le nombre est négatif.
0b0100 >> -1
# => 0b1000
Opérateurs binaires
Crystal dispose de 3 opérateurs binaires (&, |, ^) et d'un opérateur ~ pour effectuer des opérations bit à bit.
ET bit à bit (&)
L'opérateur ET binaire (&) effectue un ET bit à bit sur deux valeurs.
Il compare chaque bit de la première valeur au bit à la même position dans la seconde valeur.
Le bit résultant vaut 1 si les deux bits valent 1.
Sinon, il vaut 0.
0b0011 & 0b1010
# => 0b0010
OU bit à bit (|)
L'opérateur OU binaire (|) effectue un OU bit à bit sur deux valeurs.
Il compare également chaque bit de la première valeur au bit à la même position dans la seconde valeur.
Si l'un des deux bits vaut 1, le bit résultant vaut 1.
Sinon, il vaut 0.
0b0011 | 0b1010
# => 0b1011
OU exclusif bit à bit (^)
L'opérateur OU exclusif binaire (^) effectue un OU exclusif bit à bit.
Comme les opérateurs ET bit à bit et OU bit à bit, il compare chaque bit de la première valeur au bit à la même position dans la seconde valeur.
Si un seul d'entre eux vaut 1, le bit résultant vaut 1.
Sinon, il vaut 0.
0b0011 ^ 0b1010
# => 0b1001
NON bit à bit (~)
Enfin, l'opérateur NON bit à bit (~) inverse chacun des bits de la valeur.
Contrairement aux autres opérateurs binaires, il s'agit d'un opérateur unaire, qui agit uniquement sur la valeur à droite.
~0b1110_0010
# => 0b0001_1101
Instructions
Ton ami vient de t'envoyer un message contenant un secret important.
Pour ne pas rendre sa lecture facile aux autres, le message a été chiffré à l'aide d'une série de manipulations de bits.
Tu vas devoir écrire un programme pour t'aider à déchiffrer le message.
1. Redécale les bits
La première étape pour déchiffrer le message consiste à annuler le décalage effectué lors du chiffrement en redécalant les bits vers la gauche.
Le nombre de positions à décaler peut varier d'un message à l'autre.
Implémente la méthode Secrets.shift_back qui prend une valeur et le nombre de positions à décaler vers la gauche.
Secrets.shift_back(0b0001, 2)
# => 0b0100
2. Applique un masque de bits
L'étape suivante consiste à appliquer un masque de bits pour extraire la valeur de certains bits.
Le masque s'applique en effectuant un ET bit à bit entre la valeur et le masque.
Implémente la méthode Secrets.apply_mask qui prend une valeur et lui applique un masque.
Secrets.apply_mask(0b0110, 0b0101)
# => 0b0100
3. Mets certains bits à 1
Le décalage des bits vers la gauche a ajouté de nouveaux bits à 0.
Certains de ces nouveaux bits doivent être mis à 1.
Le OU bit à bit est utile pour mettre certains bits à 1 tout en préservant les autres.
Implémente la méthode Secrets.set_bits qui prend deux valeurs et effectue un OU bit à bit.
Secrets.set_bits(0b0110, 0b0101)
# => 0b111
4. Inverse le XOR
Une partie du processus de chiffrement applique un XOR avec une valeur convenue.
Pour retrouver la valeur d'origine, il suffit d'appliquer de nouveau le XOR entre la valeur chiffrée et la valeur convenue.
Cependant, à cause d'un malentendu, ton ami a inversé les bits de la valeur convenue (c'est-à-dire appliqué un NON bit à bit à la valeur convenue) avant d'appliquer le XOR.
Implémente la méthode Secrets.reverse_xor qui prend la valeur chiffrée et la valeur convenue et calcule la valeur d'origine.
Secrets.reverse_xor(0b1100, 0b0101)
# => 0b(0110)
Exercice d'apprentissage
