cryptage d'une chaine de caractères

Version imprimable

Bonjour à tous
j ai le problème suivant "The left-hand side of an assignment must be a variable"si je comprend ceci veut dire que le coté gauche de l assignement doit être une variable ?
donc dans mon cas "aCoder" ? pourtant je l 'ai bien déclarée ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import java.util.Scanner;
 
public class Crypto {
 
    static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    static final int DECALAGE = 4;
 
    static Scanner scanner = new Scanner(System.in);
 
    public static void main(String[] args) {
 
        System.out.println("Veuillez entrer une chaine de caracteres : ");
        String s = scanner.nextLine();
 
        // la chaine a coder
        String aCoder = "";
        // la chaine codee
        String chaineCodee = "";
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        aCoder = s;
 
        while(aCoder=="") {
        	System.out.println("Veuillez entrer une phrase SVP");
        }
 
        for (int i = 0; i <aCoder.length(); i++) {
        	for (int j = 0; j < ALPHABET.length(); j++) {
        		if(aCoder.charAt(i) != ALPHABET.charAt(j)) {
        			aCoder.charAt(i) == aCoder.charAt(i)
        		} 
        		else if(aCoder.charAt(i) == ALPHABET.charAt(j)) {
        			aCoder.charAt(i) = ALPHABET.charAt(j+DECALAGE);
        		}
 
			}
 
		}
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        System.out.format("La chaine initiale etait : '%s'\n", s);
 
        if (aCoder.isEmpty()) {
            System.out.println("La chaine a coder est vide.\n");
        } else {
            System.out.format("La chaine a coder est : '%s'\n", aCoder);
            System.out.format("La chaine codee est : '%s'\n", chaineCodee);
        }
    }
}

première instruction if:
si les caractères ne sont pas dans la chaine ALPHABET on ne les modifie pas.
2ème instruction if :
si le caractère de la chaine" aCoder" est dans ALPHABET celui-ci est modifier avec une valeur de j + CONSTANTE.
pourriez vous juste m 'aiguiller merci.

06/08/2019, 15h09
thelvin

Hello,

Certes, aCoder est une variable. Mais, tu ne fais pas aCoder = aCoder.charAt(i);, tu fais aCoder.charAt(i) = aCoder.charAt(i); .

Tu crois que aCoder.charAt(i) est une variable ?

... Bon, on va éviter de te laisser sécher quand même. Il faut savoir que les String de Java sont immutables. On ne peut pas modifier leur contenu. Tu ne peux pas prendre un objet String et changer l'une des lettres qu'il contient. Un objet String reste tel qu'il est et ça ne changera pas.

Pour obtenir ta String cryptée, tu dois donc créer un autre objet String, pas celui que tu as déjà. Cet autre objet String contiendra les lettres qu'il doit avoir. Tu peux l'obtenir en construisant des Strings l'une après l'autre, en commençant par la première lettre, puis la deuxième, puis la troisième, jusqu'à avoir construit la String finale.

merci pour ta réponse,
il me reste plus que les conditions

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.util.Scanner;
 
public class Crypto {
 
    static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    static final int DECALAGE = 4;
 
    static Scanner scanner = new Scanner(System.in);
 
    public static void main(String[] args) {
 
        System.out.println("Veuillez entrer une chaine de caracteres : ");
        String s = scanner.nextLine();
 
        // la chaine a coder
        String aCoder = "";
        // la chaine codee
        String chaineCodee = "";
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
 
 
 
//        while(aCoder=="") {
//        	System.out.println("Veuillez entrer une phrase SVP");
//        }
        aCoder = s;
 
        for (int i = 0; i <s.length(); i++) {
        	for (int j = 0; j < ALPHABET.length(); j++) {
        		if(s.charAt(i)==ALPHABET.charAt(j)) {
        			chaineCodee =chaineCodee + ALPHABET.charAt(j+DECALAGE);
        		}
			}
		}
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        System.out.format("La chaine initiale etait : '%s'\n", s);
 
        if (aCoder.isEmpty()) {
            System.out.println("La chaine a coder est vide.\n");
        } else {
            System.out.format("La chaine a coder est : '%s'\n", aCoder);
            System.out.format("La chaine codee est : '%s'\n", chaineCodee);
        }
    }
}

je n 'arrive pas à comprendre pourquoi le code m 'écrit 26 fois un caractère vide si j 'entre admettons cou cou? je vais avoir gsy "26 espaces" gsy
on entre dans la boucle ,on trouve c il est transformé en g,
on rerentre dans la boucle on trouve p il est transformé en s,
on rerentre dans la boucle on trouve u il est transformé en y
on rerentre dans la boucle on trouve un espace il est transformé en espace,
pourquoi on rerentre pas dans la boucle pour retrouvé le c du deuxième cou pour avoir gsy gsy en résultat et que la compilation affiche 26 espaces ?
je dois surement me planter dans ma vision de l 'itération mais ou ?
merci pour vos réponses

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import java.util.Scanner;
 
public class Crypto {
 
    static final String ALPHABET = "abcdefghijklmnopqrstuvwxyz";
    static final int DECALAGE = 4;
 
    static Scanner scanner = new Scanner(System.in);
 
    public static void main(String[] args) {
 
        System.out.println("Veuillez entrer une chaine de caracteres : ");
        String s = scanner.nextLine();
 
        // la chaine a coder
        String aCoder = "";
        // la chaine codee
        String chaineCodee = "";
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
 
 
 
 
 
        aCoder = s;
        for (int i = 0; i <s.length(); i++) {
        	for (int j = 0; j < ALPHABET.length(); j++) {
        		if(aCoder.charAt(i)==ALPHABET.charAt(j)) {
        			chaineCodee = chaineCodee + ALPHABET.charAt(j+DECALAGE);
 
        		}
        		else if(aCoder.charAt(i)== ' ') {
        			chaineCodee = chaineCodee + " ";
        		}
 
 
 
 
        	}
 
        }
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        System.out.format("La chaine initiale etait : '%s'\n", s);
 
        if (aCoder.isEmpty()) {
            System.out.println("La chaine a coder est vide.\n");
        } else {
            System.out.format("La chaine a coder est : '%s'\n", aCoder);
            System.out.format("La chaine codee est : '%s'\n", chaineCodee);
        }
    }
}

06/08/2019, 18h40
thelvin

C'est parce que tu n'arrêtes pas la boucle intérieure quand tu as trouvé quelle lettre c'est. Tu fais toujours 26 fois cette boucle.

Quand c'est pour une lettre, la boucle n'a d'effet qu'une seule fois sur les 26 : quand on tombe sur la bonne lettre.
Mais quand c'est pour un espace, ça remarque 26 fois que c'est un espace, et ça ajoute 26 espaces.
06/08/2019, 19h06
cpiter

ok,c'est bon j'ai réussi avec un boolean

Citation:

Envoyé par cpiter

ok,c'est bon j'ai réussi avec un boolean

Ou alors tu sors le cas de l'espace de la boucle sur l'alphabet, puisqu'on sait à 100% qu'une espace n'est pas une lettre de l'alphabet :
Code:

1 2 3 4 5 6 7 8 9 10 11 if(aCoder.charAt(i)== ' ') { chaineCodee = chaineCodee + " "; } else { for (int j = 0; j < ALPHABET.length(); j++) { if(aCoder.charAt(i)==ALPHABET.charAt(j)) { chaineCodee = chaineCodee + ALPHABET.charAt(j+DECALAGE); } } }

Ce n'est plus j'y perd mon latin mais j'y perd mon java :)
je doit préparer mon objet aCoder pour qu'il n'y ai plus que des lettres de l alphabet ou des espaces et remplacer le reste par rien c à d coucou3)op devient coucouop
je doit le réaliser avec la première boucle for mais ça ne marche pas,et ça marche avec la troisième ? décidement ces boucles il y a quelques chose que je ne comprend pas ..

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
        for (int i = 0; i < s.length(); i++) {
        	for (int j = 0; j < ALPHABET.length(); j++) {
        		if(s.charAt(i)!= ALPHABET.charAt(j)|| s.charAt(i)!= ' ') {
        			aCoder += "";
        		}else
        			aCoder += s.charAt(i);
        	}
        }
 
 
 
 
 
 
        for ( int i = 0; i < aCoder.length(); i++) {
        	if(aCoder.charAt(i) == ' ') {
        		chaineCodee = chaineCodee + " ";
        	}for (int j = 0; j < ALPHABET.length(); j++) {
        		if(aCoder.charAt(i) == ALPHABET.charAt(j)) {
        			chaineCodee += ALPHABET.charAt(j+DECALAGE);
        		}
 
        	}
        }

boucle qui fonctionne

Code:

1
2
3
4
5
6
7
8
9
10
 for (int i = 0; i < s.length(); i++) {
        	if(s.charAt(i) == ' ') {
        		aCoder += " ";
        	}for (int j = 0; j < ALPHABET.length(); j++) {
        		if(s.charAt(i)== ALPHABET.charAt(j)) {
        			aCoder += ALPHABET.charAt(j);
        		}
 
        	}
        }

Code:

1 2 if(s.charAt(i)!= ALPHABET.charAt(j)|| s.charAt(i)!= ' ') { aCoder += "";
ça dit que si le caractère en position i n'est pas dans l'alphabet à la position j, ou si ce n'est pas une espace, alors on ajoute une chaîne vide (autant ne rien faire cela dit en passant).

Alors prenons un exemple, avec le mot "b" :

b est à la position 0
quel est le caractère de ALPHABET à la position 0 : a. Ce n'est donc pas b : donc on ajoute une chaîne vide (avec un || il suffit que l'une des conditions soit vraie).
quel est le caractère de ALPHABET à la position 1 : b. C'est bien b, donc la première condition est fausse. Donc on teste la seconde : est-ce que b est une espace ? Non. Donc on ajoute une chaîne vide.
quel est le caractère de ALPHABET à la position 2 : c. Ce n'est donc pas b : donc on ajoute une chaîne vide (avec un || il suffit que l'une des conditions soit vraie).
on peut continuer comme ça jusqu'à 25...

En résumé, pour une lettre du mot à crypter, puisque toute lettre est dans l'alphabet, la première condition ne sera vraie qu'une fois au cours de la boucle sur l'alphabet (une lettre n'apparaissant qu'une fois dans l'alphabet), mais le sera forcément au moins une fois. Et si ce n'est pas le cas, comme c'est une lettre ça ne peut pas être une espace, donc la seconde condition est vraie quand la première ne l'est pas, et donc le test est forcément vrai (pour une lettre). Pour l'espace, la première condition est forcément toujours vraie pour chaque j, donc le test est forcément vrai.
Et pour les autres caractères, n'étant pas dans l'alphabet, tout comme l'espace, donc c'est pareil que pour l'espace, donc (voir ci-avant) le test est forcément vrai.

Donc le else aCoder += s.charAt(i); n'est jamais exécuté. Et heureusement, parce qu'il fait le contraire de ce qu'il faudrait faire, puisqu'il ajoute le caractère au résultat sans "cryptage" aucun.

Le premier test pour traiter tout ce qui n'est ni lettre ni espace ne pourrait être fait en un test que si on avait un moyen de tester que le caractère ne fait pas partie de l'alphabet, donc
soit faire la boucle, et ce n'est pas possible de mettre une boucle dans un if, sauf à faire une méthode. Et li faut un et (au lieu d'un ou), parce que les deux conditions doivent être fausses en même temps
Code:

1 2 3 if ( !estLettre(s.charAt(i)) && s.charAt(i)!=' ' ) { // estLettre est une méthode qui teste avec une boucle si le caractère se trouve dans ALPHABET // ne rien ajouter à aCoder ou une chaîne vide si tu veux même si çà sert à rien }
TIP: comment déterminer plus facilement (les doubles négations ce n'est pas ce qu'il y a de plus évident) si c'est un ou ou un et.

Faisons le test pour déterminer un caractère qui devrait être dans le résultat final (crypté ou pas) :

soit c'est une lettre
soit c'est une espace

Ce qui s'écrit :
Code:

1 2 3 4 5 6 if ( estLettre(c) || estEspace(c) ) { aCoder += crypterOuPas(c); } else { // ne rien faire }
Donc maintenant on veut faire l'inverse (dans le premier if, ne rien faire) : il faut donc inverser le premier test.
Code:

1 2 3 4 5 6 if ( !(estLettre(c) || estEspace(c)) ) { // ne rien faire } else { aCoder += crypterOuPas(c); }
En algèbre de Boole, !(a + b) est équivalent à !a × !b

Donc
Code:

1 2 3 4 5 6 if ( !estLettre(c) && !estEspace(c)) ) { // ne rien faire } else { aCoder += crypterOuPas(c); }
soit d'utiliser une méthode de String qui teste la présence de la lettre dans la variable ALPHABET.

String.contains()
String.indexOf()
Soit de faire le test direct sur le caractère (tu n'aurais même pas besoin de variable ALPHABET pour faire ton cryptage)
Code:

1 2 3 if ( s.charAt(i)>='a' && s.charAt(i)<='z' ) { // c'est une lettre (minuscule) }
Quant à
Code:

1 2 3 4 5 6 7 8 if(s.charAt(i) == ' ') { aCoder += " "; }for (int j = 0; j < ALPHABET.length(); j++) { if(s.charAt(i)== ALPHABET.charAt(j)) { aCoder += ALPHABET.charAt(j); } }
ça fonctionne parce que tu traites bien le cas espace dans le premier if, et le cas lettre dans la boucle. Les autres caractères n'étant ni espace ni lettre, n'enclenche pas de concaténation, donc n'apparaisse pas.

C'est d'ailleurs également le cas avec mon code précédent puisque le for n'est effectué que si le caractère n'est pas une espace (à cause du else) et que le if dans le for ne peut être vrai que pour une lettre...

PS: je suis étonné que tu n'aies pas déjà obtenu une StringIndexOutOfBoundException... tu devrais varier ton jeu de test... genre essayer de crypter le mot swaziland, ou waterzoei par exemple...

Encore merci joel pour tes réponses très explicatives,
oui c 'est pas évident ces négations de || et de &&

Code:

1
2
if(s.charAt(i)!= ALPHABET.charAt(j)|| s.charAt(i)!= ' ') {
        			aCoder += "";

Avant ton explication pour moi ça voulait dire,on supprime tout ce qui n 'est pas lettres de l'alphabet ou espace et on touche pas aux lettres et espaces mais avec ton explication je vois que ce n'est pas du tout le cas.....
mais
voilà mon code terminé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
        for (int i = 0; i < s.length(); i++) {
        	if(s.charAt(i) == ' ') {
        		aCoder += " ";
        	}for (int j = 0; j < ALPHABET.length(); j++) {
        		if(s.charAt(i)== ALPHABET.charAt(j)) {
        			aCoder += ALPHABET.charAt(j);
        		}
        	}
        }
        int value;
        for ( int i = 0; i < aCoder.length(); i++) {
        	if(aCoder.charAt(i) == ' ') {
        		chaineCodee = chaineCodee + " ";
        	}for (int j = 0; j < ALPHABET.length(); j++) {
        		if(aCoder.charAt(i) == ALPHABET.charAt(j)) {
        			value = j+DECALAGE;
        			if(value >= 26) {
        				value = value-26;
        			}
        			chaineCodee += ALPHABET.charAt(value);
 
        		}
 
        	}
        }

pour l'initialisation de la variable "value" j'avais essayé value = value%26, je ne sais pas ce qui est le mieux entre %26 et - 26 ?

08/08/2019, 09h59
thelvin

Disons que si tu veux pouvoir accepter des valeurs DECALAGE fantaisistes comme 2514, il vaut mieux utiliser un modulo %26, ça ramènera toujours de 0 à 25.