Cryptage de message en java pur

Cryptage : Exercice Chuck norris de codingame

Tout d’abord,Bonjour et  désolé de ce silence, mais je suis sur plusieurs petits projets, les futures publications seront  à la suite de ce petit exercice de java, le troisième volet de kit de survie linux, suivi d’un petit test de mise en place d’une application avec google app engine, jsp/ servlet, suivi de jsf/ primeface ! L’idée étant de pouvoir mettre en exemple ces petits exercices java via une interface fonctionnelle jee en utilisant la fonctionnalité proposée par google !!

Mais d’abord parlons java pur et jouons encore un peu avec des String et de la conversion !

Dans cet exercice gentiment baptisé chuck norris sur codingame, nous allons transformer un message quelconque et une suite de 0 avec comme règles suivantes :

  • Le message est d’abord converti en binaire
  • Ensuite, nous cryptons ce binaire en code chuck norris composé de zéro uniquement :
    • par lot, si nous avons un 1 il devient un « 00 » et un zéro devient un « 0 »
    • suivi du nombre d’occurrence consécutive en « 0

Un petit exemple en partant du binaire 1001 deviendra en chuck : « 00 0 0 00 00 0 » ce qui signifie « 1 une fois 0 deux fois 1 une fois »

 

  1. Première étape, conversion en binaire

Dans l’exercice précédent, nous avons vu comment connaître la valeur d’un caractère, et donc cette partie revient à récupérer cette valeur et la traduire en binaire  :

String message //message à convertir 

byte[] bytes = message.getBytes(); //Transforme le string en un tableau d'octets
StringBuilder binary = new StringBuilder();

for (byte b : bytes) { //Boucle sur ces octets
int val = b;

for (int i = 0; i < 8; i++) { //Boucle sur les 8 bits de l'octet
int tempo = ((val & 128) == 0 ? 0 : 1); //"&" logique bit à bit entre ton octet et 128 (10000000) 

binary.append(tempo) ; 
// renvoi donc la valeur de l'octet de poid fort (le plus a gauche) : 0 ou 1. Met cette valeur dans le String "binary".

val <<= 1; //Décale tous les bits d'un cran vers la gauche
// ainsi au prochain tour de boucle ça sera le bit suivant qui sortira
}

binary est le résultat en String du binaire !

donc si notre message est « C », binary vaut 01000011

Et maintenant? Comment traduire en code la transformation du binaire en chuck?

alternative way

2. Binaire en chuck !

Alors là, on a le choix des solutions, comme d’habitude, je vais en donner deux, je vous laisse choisir la plus élégante à vos yeux !

Commençons par traduire littéralement la règle, nous lirons donc chaque bit binaire et si c’est un 1 alors ça donne 00 et un 0 donne 0, ensuite il faut tester si le suivant est le même ou non.

donc si j’ai 111 alors je dois le traduire en 00 000, ce qui donne 1 trois fois !

Simple?

int compteur=1; // pour compter les occurrences consécutives
char n;
String chuck = ""; //ben oui allez la solutions s'appelle chuck 
String message = bytes.toString(); 
for (int j=0; j<message.length(); j++){
n= message.charAt(j);//allez caractère par caractère même si on ne parle que de un et de zero

if( j<(message.length()-1) && n==message.charAt(j+1)){

//on test si le suivant bit est le même… sans oubliez d’éviter un arrayoutofbound exception^^
compteur ++;
}
else {
if (n=='1'){

//donc si c’est un 1 c’est un 0
chuck = chuck.concat(("0 "));
}
else {

//sinon c’est un 0 et donc on le converti en 00
chuck = chuck.concat(("00 "));
}
for (int i =0; i<compteur; i++){
chuck = chuck.concat(("0"));
}
chuck = chuck.concat((" "));
compteur =1 ;
}}

Voilà rien de compliquer dans cette solution, nous sommes en terrain connu, nous manipulons des String, des caractères …

alternative way bis

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

%d blogueurs aiment cette page :