Entiers dans un tableau

Version imprimable

Voir 40 message(s) de cette discussion en une page

29/10/2010, 21h51
Roud9

Entiers dans un tableau
Bonjour,

Je voudrais stocker un certain nombre d'entier dans un tableau, mais ceux-ci doivent être générés automatiquement par l'ordinateur, donc je ne peux pas les déclarer dans le programme. J'aimerais qu'une fois qu'elles seront générées, les stocker dans un tableau.
Code:

1 2 3 4 5 private static void genererLettres() { aleatoire = generateur.nextInt(8); System.out.println(lettresAleatoires[aleatoire]); }
Merci d'avance
29/10/2010, 23h22
Ivelios

Je ne comprend pas le problème.
Tu crée un tableau et tu stocke ton nombre dedans. Ou bloques tu?
30/10/2010, 00h47
slim_java
Salut,

Le problème n'est pas clair !
Si tu veux générer des entiers aléatoires dans l'intervalle [0,N], tu dois utiliser la classe Random du package java.util :
Code:

1 2 3 4 5 private static void genererLettres() { java.util.Random aleatoire = new java.util.Random(); System.out.println( aleatoire.nextInt(N+1)); }

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
public class Main
{
 
    final static String[] lettresAleatoires =
    {
        "R", "B", "O", "V", "J", "F", "I", "N"
    };
    static String oui = "oui";
    static String lettresAuHasard = "";
    static String jouerPartie = "";
    static String CombinaisonEntree = "";
    static String chaine = "";
    static int[] tableau = new int [4];
    static int[] tableau2 = new int [4];
    static int aleatoire;
    static int sortie;
    static BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
    static Random generateur = new Random();
    static String chaineEntree;
    char tableauChaine;
    static char[] k = new char [4];
    static char[] l = new char [4];
    static int essai = 1;
 
    public static void main(String[] args) throws IOException
    {
        afficherRegles();
        demanderSiExecutionDuJeu();
 
        for (int i = 0; i < 3; i++)
        {
            genererLettres();
        }
        demanderCombinaison();
        determinerSiExact();
    }
 
    private static void afficherRegles()
    {
        System.out.println("Le programme génère automatiquement une suite de\n"
                + "caractères de quatre lettres que l'utilisateur\ntentra de "
                + "deviner en un maximum de dix essais.\nS'il n'a pas réussi lors"
                + " des essais alloués ou\ns'il quitte le jeu, la partie est "
                + "perdue.\nBonne chance! ");
        System.out.println("-------------------------------------------------");
    }
 
    private static void demanderSiExecutionDuJeu() throws IOException
    {
        System.out.println("Voulez-vous jouer une partie? (répondre oui)");
        jouerPartie = r.readLine();
 
        if (jouerPartie.equalsIgnoreCase(oui))
        {
            genererLettres();
        }
        else
        {
            System.exit(sortie);
        }
    }
 
    private static void genererLettres()
    {
        aleatoire = generateur.nextInt(8);
        chaine = "" + lettresAleatoires[aleatoire];
        k = chaine.toCharArray();
        System.out.println(k);
    }
 
    private static void demanderCombinaison() throws IOException
    {
        System.out.println("Entrez votre combinaison pour l'essai" + essai +
                " <enter> pour arrêter");
        CombinaisonEntree = r.readLine();
        l = CombinaisonEntree.toCharArray();
    }
 
    private static void determinerSiExact()
    {
 
    }
}

Je dois mettre les caractères générés par l'ordinateur et les comparer aux lettres que l'utilisateur a entrées c'est là que je ploque je ne sais pas quoi mettre dans private static void determinerSiExact()
j'ai essayé toute sorte de choses (c'est pour ça qu'il y a peut-être des variables qui ne servent à rien) mais je n'ai pas réussi à le faire fonctionner

Bonsoir,

Tout d'abord, il y a un gros risque sur la saisie du code par l'utilisateur. S'il saisit plus de 4 caractères, ça va planter.

Mais pour répondre à la question:

Code:

1
2
3
4
5
6
7
8
9
10
    private static void determinerSiExact()
    {
       for(int i=0; i<4; i++) {
         if( k[i] != l[i] ) {
           System.out.println("Perdu");
           return;
         }
       }
       System.out.println("Gagné");
    }

30/10/2010, 01h07
Roud9

Merci je vais arranger ça

Autre problème:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
                    for (int i = 0; i <= 4; i++)
        {
            if (k[i] != l[i])
            {
                {
                    System.out.println("Le caractère " + k[i] + " est"
                            + " mal placé");
                }
            }
            else
            {
                System.out.println("Le caractère " + k[i] + " est"
                        + " bien placé");
            }
        }
}

quand j'entre ovii et que la suite générée par l'ordi est ovoo, il me dit seulement " Le caractère O est mal placé ". Je veux avoir un message de ce type pour chaque caractère que j'aurai entré.

merci encore

vérifie les "{':

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for (int i = 0; i <= 4; i++)
        {
            if (k[i] != l[i])
            {
                    System.out.println("Le caractère " + k[i] + " est" + " mal placé");
 
                }
 
            else
            {
                System.out.println("Le caractère " + k[i] + " est"+ " bien placé");
 
            }
 
}

Salut,

Tu devrais créer un tableau des 26 lettres en variable de classe:
Code:

1 2 3 4 private static final String[] LES_26_LETTRES = { "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",};
Ensuite générer 4 chiffres aléatoirement de valeur 0 à 25 et "piquer" les 4 lettres qui correspondent à ces 4 chiffres aléatoires dans le tableau LES_26_LETTRES.

Méthode:
Code:

1 2 3 4 5 6 7 8 9 private static void genererLettres() { for (int i = 0; i < 4; i++) { aleatoire = new Random().nextInt(25) - 0; //On génère un nombre de 0 à 25 System.out.println(aleatoire); // pour contrôle lettresAuHasard = lettresAuHasard + LES_26_LETTRES[aleatoire]; } }
Puis tu demandes l'entrée de la chaîne supposée, tu la compares à lettresAuHasard (par exemple if(combinaisonEntree.equals(lettresAuHasard) ) et si c'est ok dans les 10 coups (<11) tu affiches le message "Gagné".

Sinon il faut que tu "fignoles" la méthode du contrôle caractère par cractère de sa présence ou non, au bon endroit ou non...
Si j'ai un peu plus de temps je cherche la solution.

Cordialement,

Dan

Re,

Je crois, au vu des postes nouveaux que tu as créés, que tu n'as plus le moral.
Je vais te donner un code que tu pouras tester (même s'il ne correspond pas tout à fait à ce que tu voudrais).

Le code:

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
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
   import java.util.Random;
   import java.util.Scanner;
   import java.io.IOException;
   import java.util.regex.Pattern;
   import java.util.regex.Matcher;
 
   public class Deviner
   {
      private static Scanner scan;
      private static final String[] LES_26_LETTRES = { "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",};
      private static String lettresAuHasard = "";
      private static String jouerPartie = "";
      private static String combinaisonEntree = "";
      private static int aleatoire;
      private static char[] genere = new char [4];
      private static char[] joue = new char [4];
      private static int nombreDeLettres = 0;
      private static int essai = 0;
 
      public static void main(String[] args) throws IOException
      {
         scan  = new Scanner(System.in); // import java.util.Scanner;
         afficherRegles();
         demanderSiExecutionDuJeu();
         demanderCombinaison();
      }
 
      private static void afficherRegles()
      {
         System.out.println("\nLe programme fabrique automatiquement une suite de quatre lettres\n"
            + "que l'utilisateur tentra de deviner en un maximum de dix coups.\n"
            + "S'il n'y parvient pas lors de ces dix essais ou s'il quitte le jeu,\n"
            + "la partie est perdue.\n\n"
            + "Bonne chance! ");
         System.out.println("-------------------------------------------------------------------");
      }
 
      private static void demanderSiExecutionDuJeu() throws IOException
      {
         System.out.print("\nVoulez-vous jouer une partie ? (oui pour jouer),\n"
            + "<autre> pour stopper: ");
         jouerPartie = scan.nextLine();
         if (jouerPartie.equalsIgnoreCase("oui"))
         {
            genererLettres();
         }
         else
         {
            System.out.println("FIN");
            System.exit(0);
         }
      }
 
      private static void genererLettres()
      {
         for (int i = 0; i < 4; i++)
         {
           aleatoire = new Random().nextInt(25) - 0; //On génère un nombre de 0 à 25
            //System.out.println(aleatoire); // pour contrôle, supprimer ensuite
            lettresAuHasard = lettresAuHasard + LES_26_LETTRES[aleatoire];
         }
         genere = lettresAuHasard.toCharArray();
 
         //Ce print sera bien entendu supprimé
         System.out.println("On doit trouver: " + lettresAuHasard + " << supprimer en fin de tests"); 
 
      }
 
      private static void demanderCombinaison() throws IOException
      {
         boolean encore = true;
         boolean erreur = true;
         while(encore)
         {
            while(erreur)
            {
               erreur = false; // sera remis true si erreur
               essai++;
               System.out.print("\nEntrez votre combinaison pour l'essai " + essai
                  + "\n<enter> pour stopper: ");
               combinaisonEntree = scan.nextLine();
               combinaisonEntree = combinaisonEntree.toUpperCase(); //le tableau des lettres
                  // ne contenant que des majuscules
 
               if(combinaisonEntree.length() == 0) //FIN ?
               {
                  System.out.println("Vous avez perdu par abandon !!!");
                  break;
               }
 
               else
               {
                  verifierSiQuatreLettres();
                  System.out.println("nombreDeLettres: " + nombreDeLettres);
                  if(nombreDeLettres != 4)
                  {
                     System.out.println("Vous devez saisir quatre lettres !!!");
                     essai--;
                     erreur = true;
                  }
                  else
                  {
                     //combinaisonEntree = combinaisonEntree.toUpperCase(); //le tableau des lettres
                     // ne contenant que des majuscules
                     joue = combinaisonEntree.toCharArray();
                     System.out.println(combinaisonEntree); 
 
                     if(combinaisonEntree.equals(lettresAuHasard))
                     {
                        System.out.println("\nBravo c'est bon en " + essai + " coup" + (essai>1?"s":"") + " !!!");
                        System.exit(0);
                     }
                     else
                     {
                        {
                           if(essai < 10)
                           {
                              System.out.println("\nC'est incorrecte !!!");
                              donnerIndices();
                              erreur = true;
                           }
                           else
                           {
                              System.out.println("\nLe nombre de coups permis est atteint !!!\n"
                                    + "Vous avez perdu !!!");
                              break;
                           }
                        }
                     }
                  }
               }
            }
 
            System.out.println("\nIf fallait saisir: " + lettresAuHasard);
            System.exit(0);
 
         }
      }
 
      private static void verifierSiQuatreLettres()
      {
         nombreDeLettres = 0;
         Pattern pattern = Pattern.compile("[A-Z]"); // compte ce qui est A à Z
 
         Matcher matcher = pattern.matcher(combinaisonEntree);
 
         while(matcher.find()) 
         {
            nombreDeLettres++;
         }
      }
 
      private static void donnerIndices()
      {
         int i = 0;
         int ii = 0;
         int ctrOk = 0;
         String libIndices = "";
 
         System.out.println("On doit trouver: " + lettresAuHasard + " << supprimer en fin de tests");
         System.out.println("Le choix est   : " + combinaisonEntree + "\n");
         for(i = 0; i <4; i++)
         {
            if(joue[i] == genere[i])
            {
               libIndices += joue[i] + " est bien en position " + (i+1); // cette ligne peut ne pas
               // être affichée, ou l'être de diverses manières en fonction d'un niveau de difficulté
               ctrOk++;
               System.out.println(libIndices);
               libIndices = "";
           }
         }
         System.out.println("\nVous avez " + ctrOk + " lettre" +  (ctrOk>1?"s":"")
            + " au bon endroit.");
      }
   }

Cordialement,

Dan

Effectivement, j'ai perdu un peu de mon moral après toutes les heures passées dessus, mais j'ai presque fini il me reste juste à vérifier si les caractères entrés par l'utilisateur sont valides ou non. Les caractères sont:

Code:

private final static String lettres = "RBOVJFIN";

et pour vérifier si la chaîne est valide ou non j'ai fait un truc du genre:

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
    private static void verifierSiValide() throws IOException
    {
        int valide = 0, nonValide = 0;
        for (int i = 0; i < 4; i++)
        {
            char test3 = lettres.charAt(i);
 
            for (int j = 0; j < 4; j++)
            {
                char test4 = lettresAleatoires.charAt(j);
 
                 if (test3 == test4)
                    {
                        if (i == j)
                        {
                            valide++;
                        }
                        else
                        {
                            nonValide++;
                        }
                    }
            }
        }
        if (nonValide >= 1)
        {
            System.out.println("Erreur!");
            demanderCombinaison();
        }
    }

Mais ça m'affiche toujours erreur pour tout ce que j'entre

Merci encore

Salut,

Quelques modifs pour avoir le nombre de lettres bien placées et de celles mal placées OU INEXISTANTES:

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
private static void verifierSiValide() throws IOException
      {
         int valide = 0, nonValide = 0;
         for (int i = 0; i < 4; i++)
         {
            char test3 = combinaisonEntree.charAt(i);
 
            for (int j = i; j < 4; j++)  // remplacer int j = 0 par j = 1
                                         // pour comparer au même endroit
            {
               char test4 = lettresAuHasard.charAt(j);
 
               if (test3 == test4)
                    //{
                     //   if (i == j)
                       // {
                  valide++; // si test3 == test4 c'est bon
                      //  }
               else
                       // {
                  nonValide++; // sinon c'est faux
               break;  // pour passer à la lettre suivante
                       // }
                   // }
            }
         }
        if (nonValide >= 1) // ou >0
         {
            System.out.println("Erreur!");
            System.out.println("valide = " + valide); // ajouter pour savoir combien
            System.out.println("nonValide = " + nonValide); // sont ok et combien non
            demanderCombinaison();
         }
       }

Cordialement,

dan

08/11/2010, 14h46
Roud9

Bonjour,

Merci ça fonctionne, mais seulement quand j'entre "RBOVJFIN". Je voudrais vérifier si la chaîne de 4 lettres entrée par l'utilisateur sont tous contenues dans "RBOVJFIN" ou non

On ne compare plus 4 lettres entrées aux 4 lettres générées aléatoirement ?

Si ces 4 lettres aléatoires sont générées à partir du tableau contenant les lettres { "R", "B", "O", "V", "J", "F", "I", "N",} c'est ce qui sera fait...

As-tu regardé et testé le code compilable que je t'ai donné plus haut le 05/11 à 19:00 h ?

Remplace le tableau des 26 lettres par tableauDeslettres:

Code:

private static final String[] TABLEAU_DES_LETTRES = { "R", "B", "O", "V", "J", "F", "I", "N",};

Mieux je te donne le code modifié:

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
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
   import java.util.Random;
   import java.util.Scanner;
   import java.io.IOException;
   import java.util.regex.Pattern;
   import java.util.regex.Matcher;
 
   public class Deviner2
   {
      private static Scanner scan;
   // avec tout l'alphabet:
      //private static final String[] TABLEAU_DES_LETTRES = { "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",};
 
   // avec seulement:  "RBOVJFIN";
      private static final String[] TABLEAU_DES_LETTRES = { "R", "B", "O", "V", "J", "F", "I", "N",};
 
      private static String lettresAuHasard = "";
      private static String jouerPartie = "";
      private static String reJouerPartie = "";
      private static String combinaisonEntree = "";
      private static int aleatoire;
      private static char[] généré; // = new char [4]; (longueur inutile)
      private static char[] joué; // = new char [4]; (longueur inutile)
      private static int nombreDeLettres = 0;
      private static int essai = 0;
      private static boolean recommencer = true;
 
      public static void main(String[] args) throws IOException
      {
         scan  = new Scanner(System.in); // import java.util.Scanner;
         while(recommencer)
         {
            recommencer = false;
            afficherRegles();
            demanderSiExecutionDuJeu();
            demanderCombinaison();
            faireAutrePartie();
         }
         try
         {
            scan.close();
         }
            catch (Exception e)
            {
               e.printStackTrace();
            }
      }
 
      private static void afficherRegles()
      {
         System.out.println("\nLe programme fabrique automatiquement une suite de quatre lettres\n"
            + "que l'utilisateur tentra de deviner en un maximum de dix coups.\n"
            + "S'il n'y parvient pas lors de ces dix essais ou s'il quitte le jeu,\n"
            + "la partie est perdue.\n\n"
            + "Bonne chance! ");
         System.out.println("-------------------------------------------------------------------");
      }
 
      private static void demanderSiExecutionDuJeu() throws IOException
      {
         if (!reJouerPartie.equalsIgnoreCase("oui")) // si rejouerPartie n'est pas oui c'est donc non
                       // et on peut demander Voulez-vous jouer une partie ?
         {
            System.out.print("\nVoulez-vous jouer une partie ? (non pour quitter),\n"
               + "<autre> pour jouer: ");
            jouerPartie = scan.nextLine();
            if(!jouerPartie.equalsIgnoreCase("non")) // si la saise n'est pas non ou NON c'est oui
               genererLettres(); // appel la méthode qui génère les 4 lettres aléatoires
         }
         else
         {
            System.out.println("FIN");
            System.exit(0);
         }
      }
 
      private static void genererLettres()
      {
         for (int i = 0; i < 4; i++)
         {
         /*
          *
          * Le but de cette méthode est de créer un tableau de char (char[] généré)
          * qui permettra ce comparer char par char les caractères entrés avec les
          * caracrères générés et donner certaines indications pour le choix suivant.
          *
          * À chacun des 4 tours de la boucle, on génère au hasard un nombre de 0 à 7
          * dans l'int aleatoire. Ce nombre est en fait l'indice de la lettre qui lui
          * correspond dans le tableau de l'alphabet (String[] TABLEAU_DES_LETTRES).
          *
          * Ensuite la lettre est concaténée dans String lettresAuHasard.
          *
          * Enfin, à la sortie de la boucle, le tableau est créée.
          *
          */
            //aleatoire = new Random().nextInt(25) - 0; //On génère un nombre de 0 à 25
            aleatoire = new Random().nextInt(7) - 0; //On génère un nombre de 0 à 7 <<<<<<<<<<<<<<<<<<<<
            lettresAuHasard += TABLEAU_DES_LETTRES[aleatoire]; //concaténation
         }
         généré = lettresAuHasard.toCharArray();
 
          //Ce print sera bien entendu supprimé
         System.out.println("On doit trouver: " + lettresAuHasard + " << supprimer en fin de tests"); 
 
      }
 
      private static void demanderCombinaison() throws IOException
      {
         boolean encore = true;
         boolean erreur = true;
         while(encore)
         {
            while(erreur)
            {
               erreur = false; // sera remis true si erreur
               essai++;
               System.out.print("\nEntrez votre combinaison pour l'essai " + essai
                  + "\n<enter> pour stopper: ");
               combinaisonEntree = scan.nextLine();
               combinaisonEntree = combinaisonEntree.toUpperCase(); //le tableau des lettres
                  // ne contenant que des majuscules, les comparaisons de lettres seront faites
            		// de majuscule à majuscule
 
               if(combinaisonEntree.length() == 0) //si la longueur entrée c'est terminé
               {
                  System.out.println("Vous avez perdu par abandon !!!");
                  System.exit(0); // on ne demande même pas si on veut rejouer
               }
               else
               {
                  verifierSiQuatreLettres(); // on vérifie qu'on a bien 4 lettres
                  System.out.println("nombreDeLettres: " + nombreDeLettres);
                  if(nombreDeLettres != 4)
                  {
                     System.out.println("Vous devez saisir quatre lettres !!!");
                     essai--; // on annule l'incrémentation de nombre de coups joués
                     erreur = true; //permet de redemander la saisie
                  }
                  else
                  {
                     joué = combinaisonEntree.toCharArray();
                     System.out.println(combinaisonEntree); 
 
                  // on peut tester tout de suit si par chance on a les 4 lettres
                  // si c'est le cas, c'est inutile de tester autre chose
                     if(combinaisonEntree.equals(lettresAuHasard))
                     {
                        System.out.println("\nBravo c'est bon en " + essai + " coup" + (essai>1?"s":"") + " !!!");
                        break;
                     }
                     else
                     {
                        {
                           if(essai < 10)
                           {
                             // System.out.println("\nC'est incorrecte !!!");
                              //verifierSiValide(); // <<<<<<<<<<<<<<<<<<<<<<<<<<<<
                              donnerIndices(); // c'est ici qu'on donne entre autre le nombre de
                                               // lettres valides ou non valides saisies
                              erreur = true;
                           }
                           else
                           {
                              System.out.println("\nLe nombre de coups permis est atteint !!!\n"
                                    + "Vous avez perdu !!!");
                              System.out.println("\nIf fallait saisir: " + lettresAuHasard);
                              break;
                           }
                        }
                     }
                  }
               }
            }
            break;
         }
      }
 
      private static void verifierSiQuatreLettres()
      {
      /*
       *
       * Ici nous vérifions que le choix du joueur est bien de QUATRE LETTRES MAJUSCULES.
       * Le tableau TABLEAU_DES_LETTRES[] contenant les lettres EN MAJUSCULES,
       * le joueur peut quand même saisir ses quatre lettres comme il veut, en minuscules
       * ou en majuscules car son choix est converti immédiatement en MAJUSCULES.
       *
       */
      //                                 "RBOVJFIN"
         nombreDeLettres = 0;
         Pattern pattern = Pattern.compile("[A-Z]"); // compte ce qui est A à Z
 
         Matcher matcher = pattern.matcher(combinaisonEntree);
 
         while(matcher.find()) 
         {
            nombreDeLettres++;
         }
         // Le nombre de lettres sera testé au retour de cette méthode...
      }
 
      private static void donnerIndices()
      {
         int valide = 0, nonValide = 0;
         int i = 0;
         int ii = 0;
         int ctrOk = 0;
         String libIndices = "";
 
         System.out.println("On doit trouver: " + lettresAuHasard + " << supprimer en fin de tests");
         System.out.println("Le choix est   : " + combinaisonEntree + "\n");
         for(i = 0; i <4; i++)
         {
            if(joué[i] == généré[i])
            {
               libIndices += joué[i] + " est bien en position " + (i+1); // cette ligne peut ne pas
               // être affichée, ou l'être de diverses manières en fonction d'un niveau de difficlté
               valide++;
               ctrOk++;
               System.out.println(libIndices);
               libIndices = "";
            }
            else
               nonValide++;
         }
         System.out.println("\nVous avez " + ctrOk + " lettre" +  (ctrOk>1?"s":"")
            + " au bon endroit.");
         System.out.println("\nvalide = " + valide);
         System.out.println("\nnoValide = " + nonValide);
      }
 
      private static void verifierSiValide() throws IOException
      {
         int valide = 0, nonValide = 0;
         for (int i = 0; i < 4; i++)
         {
            char test3 = combinaisonEntree.charAt(i);
 
            for (int j = i; j < 4; j++)  // remplacer int j = 0 par j = 1
                                         // pour comparer au même endroit
            {
               char test4 = lettresAuHasard.charAt(j);
 
               if (test3 == test4)
                    //{
                     //   if (i == j)
                       // {
                  valide++; // si test3 == test4 c'est bon
                      //  }
               else
                       // {
                  nonValide++; // sinon c'est faux
               break;
                       // }
                   // }
            }
         }
         if (nonValide >= 1) // ou >0
         {
            System.out.println("Erreur!");
            System.out.println("valide = " + valide); // ajouter pour savoir combien
            System.out.println("nonValide = " + nonValide); // sont ok et combien non
            //demanderCombinaison(); n'est pas nécéssaire: on doit revenir après l'appel depuis
         	//                                             la méthode demanderCombinaison()
         } 
      }
 
      private static void faireAutrePartie()
      {
         System.out.print("\nVoulez-vous faire une autre partie ? (non pour quitter),\n"
                  + "<autre> pour rejouer: ");
         reJouerPartie = scan.nextLine();
         if (reJouerPartie.equalsIgnoreCase("non"))
            System.exit(0);
         else
         {
            reJouerPartie = "oui";
            //jouerPartie = "oui";
            recommencer = true;
            lettresAuHasard = "";
            essai = 0;
         }
      }
   }

Copier coller compiler essayer...

Peut-être que ce code te servira à adapter le tien...

Cordialement,

Dan

Bonjour,

merci pour la modification ça fonctionne. Mais pour vérifier si les caractères entrés sont valides ou non, j'ai pensé à quelque chose du genre :

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
        int valide = 0;
 
        char[] test = lettresEntrees.toCharArray();
        char[] test2 = lettres.toCharArray();
 
        for (int k = 0; k < 4; k++)
        {
            tableauTest[k] = test[k];
        }
 
        for (int i = 0; i < 4; i++)
        {
            for (int j = i; j < 4; j++)
            {
                if (tableauTest[i] == test2[j])
                {
                    valide++;
                }
            }
        }
        if (valide == 4)
        {
            determinerSiExact();
        }

Mais j'ignore pourquoi ça ne fonctionne pas

Merci d'avance

09/11/2010, 03h18
danimo

Salut,

C'est quoi le tableau tableauTest[] ?
09/11/2010, 03h55
Roud9

C'est un nom pour tester si ça fonctionne, mais ça représente les caractères { "R", "B", "O", "V", "J", "F", "I", "N"}
09/11/2010, 07h15
danimo

Re,

Tu as testé mon code (Class deviner2) ?

Le tableau que j'ai nommé TABLEAU_DES_LETTRES est celui dont se sert le programme pour créer les 4 lettres aléatoires qui seront donc 4 des lettres de { "R", "B", "O", "V", "J", "F", "I", "N"}.

Regarde bien le code de la classe Deviner2 pour voir entre autres choses comment on génère ces 4 lettres, ça se passe dans la méthode demanderSiExecutionDuJeu() si on accepte de jouer.

Ensuite on demande la saisie des 4 lettres choisies (méthode demanderCombinaison(), et si on n'entre rien on sort du programme.

Dans le cas contraire, on vérifie qu'il n'y a que des lettres et qu'il y en a bien 4 sinon on demande de resaisir. Si c'est oui, on teste tout de suite les lettres entrées sont les mêmes que les lettres aléatoires.

Si oui c'est gagné et on demande si le joueur veut faire une autre partie.

Si non on commence les contrôles si on est dans la limite des 10 tentatives alouées, à savoir compter entre autres choses les lettres valides et non valides de la manières que tu indiques dans ta dernière question ( méthode donnerIndices() et non plus la méthode verifierSiValide() ).

Teste ce code, lis le bien et pose moi toutes les questions que tu veux.

Normalement ce programme est fait pour fonctionner avec TABLEAU_DES_LETTRES contenant les 26 lettres de l'alphbet et il n'y a pas grand choses à changer pour ça: c'est resté en commentaires.
Cordialement,
Dan
10/11/2010, 00h12
Roud9

Bonjour,

Après avoir testé ton code plusieurs fois, je conclus qui fait exactement ce que je veux, sauf une exception : vérifier si les lettres entrées sont valides. Je me suis peut-être mal exprimé, mais je voudrais que si toutes les lettres entrées (4) se trouvent dans ma chaîne de caractères (peu importe la disposition des lettres), le programme passe à l'étape suivante, autrement, il demande encore d'entrer une chaîne.

Ma chaîne est :

Code:

private final static String LETTRES = "RBOVJFIN";

Si j'entre "BROJ", que cela soit accepté (parce que les lettres sont toutes dans le tableau) de même que "BBBB", mais si j'entre "NGVI", que cela soit révisé et une autre chaîne m'est demandée, car le "G" n'est pas dans le tableau, de même que "ZZZZ".

Merci encore

OK,

Alors teste ce code:

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
private static void verifierSiValide() throws IOException
      {
      // "RBOVJFIN"
         boolean err = false;
         int valide = 0, nonValide = 0;
 
         for (int i = 0; i < 4; i++)
         {
            char test3 = combinaisonEntree.charAt(i);
 
            for (int j = 0; j < 4; j++)
            {
               char test4 = lettresAuHasard.charAt(j);
 
               if (test3 == test4)
               {
                  err = false;
                  valide++;
                  break;
               }
               else //on doit vérifier si cette lettre existe ailleurs
                  err = true;
            }
            if(err)
               nonValide++;
         }
         if (nonValide >0)
            System.out.println("Erreur!");
         else
            System.out.println("\nBravo c'est bon en " + essai
                           + " coup" + (essai>1?"s":"") + " !!!");
         System.out.println("valide = " + valide);
         System.out.println("nonValide = " + nonValide);
      }

Cordialement,

Dan

Voir 40 message(s) de cette discussion en une page