Crypto A devient B et B devient C

**domxaline** · 26/07/2015, 12h41

bonjour
mon prg consiste à faire:
A devient B et B devient C etc,
si l’utilisateur entre une phrase et le prg change tous les A en B et tous les B en C etc...
quand j'écris mon prg je suis arrêté dans cette ligne:
if(let<'a' & let > 'z')
et prg me dit que :
the operator < is undefined for the argument StringBuilder, char
quel est la solution pour remédier ce problème et continuer mon prg

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
import java.util.Scanner;
public class Divers4 
{	
 public static void main(String[] args) 
 {
	String bla, cod,alpha;
	int i, pos;
	System.out.println("Entrez la phrase à coder:");
	Scanner sc=new Scanner(System.in);
	bla=sc.nextLine();
	alpha="abcdefghijklmnopqrstuvwxyz";
	cod="";
	for(i=1;i<bla.length();i++)
	{
		StringBuilder let=(new StringBuilder(bla).replace(1,i, bla));
		if(let<'a' & let > 'z')
	}
 }
}

merci d'avance

**joel.drigo** · 26/07/2015, 13h21

Salut,

Il n'y a pas de solution directe pour que cette expression fonctionne : let est un StringBuilder et 'a' un char, donc il est impossible de les comparer.

De tout manière, c'est l'algorithme qui est n'importe quoi, même si ce n'est que le début.

Déjà, StringBuilder let=(new StringBuilder(bla).replace(1,i, bla)); n'a aucun intérêt.
ça remplace les caractères entre 1 et i (exclu) par la chaine elle-même.
Donc

[1,1[ par bla (ça insert bla entre 1, et 2)
[1,2[ par bla
[1,3[ par bla
...

Essaye déjà d'exécuter ce programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Test {
	public static void main(String[] args) {
		String bla = "abcd";
		for (int i = 1; i < bla.length(); i++) {
			StringBuilder let = (new StringBuilder(bla).replace(1, i, bla));
			System.out.println(let);
		}
	}
}

Ça donne ça :

aabcdbcd
aabcdcd
aabcdd

Quel rapport avec ce que tu cherches à faire ?

Ensuite, au sujet de let<'a' & let > 'z'

& n'est pas l'opérateur logique booléen AND, mais l'opérateur bit à bit AND (ça ne change pas le résultat dans ton cas, mais ça une importance (avec le && la seconde expression n'est pas évaluée si la première est false)
Essaye d'exécuter ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public class Test {
	public static void main(String[] args) {
		String s1="abc";
		String s2=null;
		System.out.println( s2!=null && s2.equals(s1));
		System.out.println( s2!=null & s2.equals(s1));
	}
}

ensuite, même si let était un caractère, cette expression serait toujours false : en effet, il n'existe aucun caractère qui peut être à la fois inférieur à a, et supérieur à z (qui est supérieur à a).

Pour faire ton programme, il suffit de parcourir tous les caractères de la chaine (y compris le premier, donc faire partir i de 0 !), puis pour chaque caractère c, s'il est compris entre a inclus et z exclus ([c]c>='a' && c<'z'[c]) le remplacer par (char)(c+1), et si il est égal à z, le remplacer par a (Attention à la problématique de la casse : je te laisse transposer)
Par contre, cet algorithme n'est pas généralisable (faire un décalage de n au lieu de 1). Pour ça, il est plus interessant de calculer tout d'abord la table de conversion, en partant de la liste de tous les caractères, de les décaler dans un tableau par exemple, puis d'utiliser le tableau comme table de conversion. Je te laisse y réflechir (pense juste que l'index du caractère c dans le tableau c'est c-'a')...

**domxaline** · 26/07/2015, 16h47

j'ai écrit ainsi mais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import java.util.Scanner;
public class Divers5 
{
	public static void main(String args[])
	{
        char first[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        char second[]={'b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','a'};
 
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the name: ");
        String n;
        n=sc.nextLine();
        int len=n.length();
        for(int i=0;i<len;i++)
        {
         char c=n.charAt(i);
         for(int j=0;j<26;j++)
         {
          if(c==first[j])
          {
           int pos1=j;
           System.out.print(second[pos1]);
          }    
         }
        }
       }
	}

le pg marche mais ces deux lignes un peu longue vous croyiez pas?,est ce qu'il y a moyen le reduire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
char first[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
char second[]={'b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','a'};

**domxaline** · 26/07/2015, 16h56

en plus mon code ne prend pas en compte le caractère espace

**joel.drigo** · 26/07/2015, 17h37

Envoyé par domxaline

en plus mon code ne prend pas en compte le caractère espace

Ni les caractères qui ne sont pas des lettres entre a z : ni les chiffres, ni les caractères accentués et, surtout, ni les majuscules !

Envoyé par domxaline

j'ai écrit ainsi mais:
le pg marche mais ces deux lignes un peu longue vous croyiez pas?,est ce qu'il y a moyen le reduire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
char first[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
char second[]={'b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','a'};

Si, je crois. Déjà, on a pas besoin de 2 tableaux. Ensuite, on peut générer le second tableau automatiquement.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	public static void main(String[] args) {
 
		System.out.println(Arrays.toString(createTableCodage(1)));
		System.out.println(Arrays.toString(createTableCodage(2)));
		System.out.println(Arrays.toString(createTableCodage(-1)));
		System.out.println(Arrays.toString(createTableCodage(0)));
		System.out.println(Arrays.toString(createTableCodage(28)));
		System.out.println(Arrays.toString(createTableCodage(-28)));
 
	}
 
	public static char[] createTableCodage(int decalage) {
 
		final int nb = 'z'-'a'+1;
 
		if ( decalage<0 ) {
			decalage = -((-decalage)%nb); // on pourrait interdire des décalages superieur au max
		}
		else if ( decalage>nb ) {
			decalage = decalage%nb; // on pourrait interdire des décalages superieur au max
		}
 
		char[] table = new char[nb];
 
		for(char c='a'; c<='z'; c++) {
 
			int nc = c + decalage; 
 
			if ( decalage<0 ) {
				if ( nc<'a' ) {
					nc = 'z' + (nc - 'a' + 1);
				}
			} else if ( decalage>0 ) {
				if ( nc>'z' ) {
					nc = 'a' + (nc - 'z' - 1);
				}
			}
 
			table[c-'a']=(char)nc;
 
		}
 
		return table;
 
	}

Et pour l'utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static void main(String args[]) {
		char table[] = createTableCodage(1);
 
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter the name: ");
		String n;
		n = sc.nextLine();
		int len = n.length();
		for (int i = 0; i < len; i++) {
			char c = n.charAt(i);
			int pos = c-'a';
			if ( pos>=0 && pos<table.length ) {
				System.out.print(table[pos]);
			}
			else {
				System.out.print(" "); // non codable
			}
		}
	}

Pour traiter les majuscules, on sait qu'on peut utiliser la même table, mais juste faire un décalage et repasser en majuscule.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
	public static void main(String args[]) {
		char table[] = createTableCodage(1);
 
		Scanner sc = new Scanner(System.in);
		System.out.println("Enter the name: ");
		String n;
		n = sc.nextLine();
		int len = n.length();
		for (int i = 0; i < len; i++) {
			char c = n.charAt(i);
			boolean maj = Character.isUpperCase(c);
			if (maj) {
				c=Character.toLowerCase(c);
			}
			int pos = c-'a';
			if ( pos>=0 && pos<table.length ) {
				if ( maj ) {
					System.out.print(Character.toUpperCase(table[pos]));
				}
				else {
					System.out.print(table[pos]);
				}
			}
			else {
				System.out.print(" "); // non codable
			}
		}
	}

**domxaline** · 27/07/2015, 22h43

merci pour votre aide
en compilant votre prg j'ai le message suivant; ile veut la méthode "createTableCodage"
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
The method createTableCodage(int) is undefined for the type Testing7

at Testing7.main(Testing7.java:6)
pourtant on a cette méthode, bizarre!!!

**joel.drigo** · 27/07/2015, 23h13

Mais tu l'as bien mise (createTableCodage) dans la même classe où se trouve ta méthode main ?

**domxaline** · 27/07/2015, 23h39

j'avais fait deux classe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.Arrays;
import java.util.Scanner;
public class Testing6 
{
 public static void main(String[] args) 
 {
	 System.out.println(Arrays.toString(createTableCodage(1)));
	   System.out.println(Arrays.toString(createTableCodage(2)));
	   System.out.println(Arrays.toString(createTableCodage(-1)));
	   System.out.println(Arrays.toString(createTableCodage(0)));
	   System.out.println(Arrays.toString(createTableCodage(28)));
	   System.out.println(Arrays.toString(createTableCodage(-28))); 
	 }
 
	   public static char[] createTableCodage(int decalage) 
	   { 
	    final int nb = 'z'-'a'+1;
 
	    if ( decalage<0 ) 
	    {
	       decalage = -((-decalage)%nb); // on pourrait interdire des décalages superieur au max
	    }
	    else if ( decalage>nb ) 
	    {
	      decalage = decalage%nb; // on pourrait interdire des décalages superieur au max
	    }
 
	     char[] table = new char[nb];
 
	     for(char c='a'; c<='z'; c++) 
	     {
	        int nc = c + decalage;  
	        if ( decalage<0 ) 
	        {
	            if ( nc<'a' ) 
	            {
	               nc = 'z' + (nc - 'a' + 1);
	            }
	        } 
 
	        else if ( decalage>0 ) 
	        {
	          if ( nc>'z' ) 
	          {
	             nc = 'a' + (nc - 'z' - 1);
	          }
	        }
	        table[c-'a']=(char)nc; 
	       } 
	       return table;
	    }	      
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import java.util.Scanner;
public class Testing7 
{
 public static void main(String[] args) 
 {
	 char table[] = createTableCodage(1); 
	  Scanner sc = new Scanner(System.in);
	  System.out.println("Enter the name: ");
	  String n;
	  n = sc.nextLine();
	  int len = n.length();
	  for (int i = 0; i < len; i++) 
	  {
	    char c = n.charAt(i);
	    int pos = c-'a';
	    if ( pos>=0 && pos<table.length ) 
	    {
	      System.out.print(table[pos]);
	    }
	    else 
	    {
	       System.out.print(" "); // non codable
	    }
	  }
	}
 }

**joel.drigo** · 27/07/2015, 23h42

Dans ce cas (appel de méthode statique située dans une autre classe), il faut toujours indiquer la classe où se trouve la méthode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
import java.util.Scanner;
public class Testing7 
{
public static void main(String[] args) 
 {
	 char table[] = Testing6.createTableCodage(1); 
 
/*... */

**domxaline** · 27/07/2015, 23h57

c'est bon, ça marche bien
merci beaucoup

**domxaline** · 10/12/2015, 19h36

je reouvert ce discussion,quand même,certaine choses sont noir pour moi
code source:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
import java.util.Scanner;
public class Essaie1 
{
	 public static void main(String[] args) 
	 {
		  char table[] = TabEssaie.createTableCodage(1); 
		  Scanner sc = new Scanner(System.in);
	          System.out.println("Enter the name: ");
		  String n;
		  n = sc.nextLine();
		  int len = n.length();
		  for (int i = 0; i < len; i++) 
                  {
	            char c = n.charAt(i);
		    boolean maj = Character.isUpperCase(c);
		    if (maj) 
	            {
		      c=Character.toLowerCase(c);
		    }
		    int pos = c-'a';
		    if ( pos>=0 && pos<table.length )
	            {
		      if ( maj ) 
	              {
			System.out.print(Character.toUpperCase(table[pos]));
	              }
		     else
	             {
		        System.out.print(table[pos]);
	             }
	           }
	          else 
	          {
	             System.out.print(" "); // non codable
	          }
	        }
	      }
	    }

import java.util.Arrays;
import java.util.Scanner;[B]
public class TabEssaie 
{
 public static void main(String[] args) 
 {
	 System.out.println(Arrays.toString(createTableCodage(1)));
	   System.out.println(Arrays.toString(createTableCodage(2)));
	   System.out.println(Arrays.toString(createTableCodage(-1)));
	   System.out.println(Arrays.toString(createTableCodage(0)));
	   System.out.println(Arrays.toString(createTableCodage(28)));
	   System.out.println(Arrays.toString(createTableCodage(-28))); 
	 }
 
	   public static char[] createTableCodage(int decalage) // ici decalage est 1
	   { 
	    final int nb = 'z'-'a'+1;
 
	    if ( decalage<0 ) 
	    {
	       decalage = -((-decalage)%nb); // on pourrait interdire des décalages superieur au max
	    }
	    else if ( decalage>nb ) 
	    {
	      decalage = decalage%nb; // on pourrait interdire des décalages superieur au max
	    }
 
	     char[] table = new char[nb];
 
	     for(char c='a'; c<='z'; c++) 
	     {
	        int nc = c + decalage;   // ici debug indique valeur du nc est 98? C'est comment?
	        if ( decalage<0 ) 
	        {
	            if ( nc<'a' ) 
	            {
	               nc = 'z' + (nc - 'a' + 1);
	            }
	        } 
 
	        else if ( decalage>0 ) 
	        {
	          if ( nc>'z' ) 
	          {
	             nc = 'a' + (nc - 'z' - 1);
	          }
	        }
	        table[c-'a']=(char)nc; 
	       } 
	       return table;
	    }	      
}

Mes questions:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 if ( decalage<0 ) // ici decalage est 1 n'est ce pas 
	    {
	       decalage = -((-decalage)%nb); // on pourrait interdire des décalages superieur au max
               //cette ligne je ne comprend pas
	    }
	    else if ( decalage>nb ) 
	    {
	      decalage = decalage%nb; // on pourrait interdire des décalages superieur au max
               //cette ligne aussi je ne comprend pas
	    }

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
for(char c='a'; c<='z'; c++) 
	     {
	        int nc = c + decalage; // ici debug se trouve 98, comment il la trouvé ça? 
	        if ( decalage<0 ) 
	        {
	            if ( nc<'a' ) 
	            {
	               nc = 'z' + (nc - 'a' + 1);
	            }
	        }

merci pour vos aides

**joel.drigo** · 10/12/2015, 21h31

if ( decalage<0 ) ici decalage est 1 n'est ce pas
Il vaut 1 si on appelle la méthode en passant 1 comme paramètre, mais il peut valloir n'importe quoi, 42, 378 ou -3000
decalage = -((-decalage)%nb; cette ligne je ne comprend pas
On exécute ça lorsque decalage < 0, donc un décalage strictement négatif. On commence par faire -decalage, ce qui le rend strictement positif. Ensuite le modulo permet d'éviter qu'on ait un décalage supérieur à la taille du tableau (le nombre de lettres dans le tableau, donc nb=26). Ensuite on le repasse en négatif.
- Si decalage vaut -1, le rendre positif fait qu'il vaut 1, puis le reste de la division par 26, est 1 (1/26=0, 1-0=1, soit 1=26*0+1), puis on le remet en négatif : donc il vaut bien -1.
- Si decalage vaut -10, le rendre positif fait qu'il vaut 10, puis le reste de la division par 26, est 10 ( 10=26*0+10), puis on le remet en négatif : donc il vaut bien -10.
- Si decalage vaut -26, le rendre positif fait qu'il vaut 26, puis le reste de la division par 26, est 0 (26=26*1+0), puis on le remet en négatif : donc décalage vaut -0.
  a décalé de 26 lettres à gauche (décalé 26 fois de 1, on retombe sur a), c'est bien a décalé de 0 à gauche.
- si decalage vaut -36, ça donne 36, puis 10 (36=26*1+10), donc -10
  L'avantage, c'est qu'on sait qu'on retombe toujours dans le tableau au bout d'un décalage. Alors qu'avec 36 c'est 2 (au moins une fois 26, puis 10), avec 72 (26*2+20), c'est 3. Ceci simplifie le traitement ici lorsqu'on décale de plus que le nombre de lettre.
- etc.
decalage = decalage%nb; cette ligne je ne comprend pas
C'est la même chose, mais pour un décalage positif, plus facile à comprendre. Rappel dans le tableau 'a' est en position 0, 'Z' en position 25.
Supposons que decalage vaut 35, 35=26*1+9. On veut donc décaler donc a de 35 : 'a '+ 35 est forcément supérieur à 'z', puisque 'a' + 25 = 'z', donc 'a'+35 sort de l'espace 'a'-'z', de 10.
Donc on fait nc = 'a' + (nc - 'z' - 1);, soit 'a' + (10-1), soit 'j'. Mais on fait le décalage avec 9, pas 35, donc on fait 'a'+9, ce qui vaut la même chose, j.
Alors pourquoi on fait les 2. Parce que quand on décale z en revanche, on sort forcément, malgré le modulo, donc il faut quand même faire le traitement qu'on fait si nc>'z'. Non seulement on le fait moins souvent grâce au modulo (parce qu'on est plus souvent entre 'a' et 'z' après décalage, mais aussi parce qu'une valeur quelconque comme 378, on sortirait de beaucoup de 'a'-'z', et le calcul serait plus compliqué pour revenir dans l'intervalle (on pourrait le faire par boucle tant que on est en dehors, on fait -26, ou alors avec une formule à base de modulo, qu'on devrait faire pour chaque lettre décalée : autant ne le faire qu'une fois au début.
int nc = c + decalage; ici debug se trouve 98, comment il la trouvé ça?
c vaut 'a', soit 97 en int (essaye de faire System.out.println((int)'a'); pour voir ce que ça affiche.) Parce que tout de tout façon est représenté par des nombres sur un ordinateur, et là on simplement dit que le nombre 97 c'était la lettre a pour le type char. Plus le décalage de 1, ça fait 98.

**domxaline** · 11/12/2015, 17h08

merci jo
personne peut m'expliquer mieux que toi,merci encore une fois.

encore une question dans le commentaire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
if ( decalage<0 ) 
	    {
	       decalage = -((-decalage)%nb); // on pourrait interdire des décalages superieur au max
	    }
	    else if ( decalage>nb ) 
	    {
	      decalage = decalage%nb; // on pourrait interdire des décalages superieur au max
	    }

ici, un decalage negatif un autre decalage positif, mais dans la commentaire dit la même chose est ce que c'est normal?
"on pourrait interdire des décalages superieur au max"

**joel.drigo** · 11/12/2015, 17h18

Envoyé par domxaline

ci, un decalage negatif un autre decalage positif, mais dans la commentaire dit la même chose est ce que c'est normal?
"on pourrait interdire des décalages superieur au max"

Bah, j'ai écrit ça un peu "résumé", parce que je ne voulais pas passer du temps à écrire toute une prose pour expliquer que l'idée était de soulever une exception lorsqu'on passe un décalage supérieur à 25 ou inférieur à 1 dans les deux sens (donc soit sans effet, 0 et multiples de 26, soit d'effet identique à un décalage % 26.

**domxaline** · 11/12/2015, 18h17

je n'ai pas su bien expliquer, je pose question sur ces phrases commentaire
"// on pourrait interdire des décalages superieur au max"

**domxaline** · 11/12/2015, 19h06

Si decalage vaut -10, le rendre positif fait qu'il vaut 10, puis le reste de la division par 26, est 10 (10-26*0+10), puis on le remet en négatif : donc il vaut bien -10

ici division par 26, est 10 (10=26*0+10), n'est pas?

si decalage vaut -36, ça donne 36, puis 10 (36=26*1+10), donc -10

ça donne 26, puis 10 n'est ce pas?

ce bien tu m'explique bien, merci

**joel.drigo** · 11/12/2015, 19h29

Envoyé par domxaline

ici division par 26, est 10 (10=26*0+10), n'est pas?

10 = 26*0+10

**domxaline** · 12/12/2015, 18h09

j'ai encore une question sur cette parti du code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
for(char c='a'; c<='z'; c++) 
	     {
	        int nc = c + decalage; // c= a veut dire 97, et 1 plus fait 98 
	        if ( decalage<0 ) // si decalage < 0 veut dire 1<0 non
	        {
	            if ( nc<'a' ) 
	            {
	               nc = 'z' + (nc - 'a' + 1);
	            }
	        } 
 
	        else if ( decalage>0 ) // il vient ici 1>0 oui
	        {
	          if ( nc>'z' ) //si 98>122 non, alors ici il manque pas une instruction?
	          {
	             nc = 'a' + (nc - 'z' - 1);
	          }
	        }
	        table[c-'a']=(char)nc; //prg vient ici 
	       } 
	       return table;

[B][U] table[c-'a']=(char)nc;
veut dire quoi svp?

final int nb = 'z'-'a'+1;
est ce que ça veut dire ça : nb= 122-97+1?

**joel.drigo** · 12/12/2015, 18h49

Envoyé par domxaline

j'ai encore une question sur cette parti du code

ça fait 2 questions

Envoyé par domxaline

final int nb = 'z'-'a'+1;
est ce que ça veut dire ça : nb= 122-97+1?

Exactement.

Envoyé par domxaline

table[c-'a']=(char)nc;
veut dire quoi svp?

nc est la nouvelle lettre correspondant à la position de c dans le tableau, mais sous forme de int, donc on la caste en char pour la mettre dans le tableau.
c est la lettre dans le tableau, donc pour connaitre sa position, on fait la différence avec la première lettre 'a', qui est en position 0. Donc pour 'a', ça fait 0, pour 'b', 1, pour 'c', 2, etc.

**domxaline** · 12/12/2015, 19h19

bien sur, il y a 2 questions, j'ai compris une d'elle mais l'autre ?

au lieu de dire comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 for(char c='a'; c<='z'; c++) 
	     {
	        int nc = c + decalage; // c= a veut dire 97, et 1 plus fait 98 
	        if ( decalage<0 ) // si decalage < 0 veut dire 1<0 non
	        {
	            if ( nc<'a' ) 
	            {
	               nc = 'z' + (nc - 'a' + 1);
	            }
	        } 
 
	        else if ( decalage>0 ) // il vient ici 1>0 oui
	        {
	          if ( nc>'z' ) //si 98>122 non, alors ici il manque pas une instruction?
	          {
	             nc = 'a' + (nc - 'z' - 1);
	          }
	        }
	        table[c-'a']=(char)nc; //prg vient ici 
	       } 
	       return table;

disons comme ça, sinon ça me complique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
                     for(char i='a'; i<='z'; i++) 
		     {
		    	 int nc = i + decalage; 
		         if ( decalage<0 ) 
		        {
		            if ( nc<'a' ) 
		            {
		               nc = 'z' + (nc - 'a' + 1);
		            }
		        } 

		        else if ( decalage>0 ) 
		        {
		          if ( nc>'z' ) 
		          {
		             nc = 'a' + (nc - 'z' - 1);
		          }
		        }
		        table[i-'a']=(char)nc;
		       } 
		       return table;

maintenant
table[c-'a']=(char)nc;

a été changé comme suivant:
table[i-'a']=(char)nc;

table[i-'a']
signifie que :
table[0-'a']
quel est la solution de ce soustraction svp

je crois que je comprend comme ceci
dans la position 0 est a, position 1 est b et ainsi de suite n'est ce pas?

Crypto A devient B et B devient C

avec Java

Discussions similaires

Partager

Partager