Compter le nombre de lettres différentes dans un mot

Bonjour à toutes et à tous,

Je suis débutant et j’ai un exercice à faire en java.

Je dois faire un programme qui tire un mot au sort et le programme affiche le nombre de lettres différentes du mot.

Voila ce que j'ai fait mais cela ne fonctionne pas.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class MotAuSort{ public static void main(String[] args){ char[] unmot; for (int num=0; num<1; num=num+1){ unmot = MOOC.motAuSort(); for (int numlet=0; numlet<14; numlet=numlet+1) System.out.print(unmot[numlet]); for(i=0; i<num; i=i+1){ boolean nouvelle =true; if(nouvelle){ compteur=compteur+1; } } } }

---

Je n'arrive pas à trouver mon ou mes erreurs.

Merci d'avance pour votre précieuse aide.

Chm412

Salut,

1. Premièrement, tu utilises deux variables non déclarées : compteur et i.
   En Java, il faut toujours déclarer toutes les variables. En plus, elles doivent avoir été initialisée avant de pouvoir utiliser leur valeur.
   AJouter donc
   
   Code:

   ---

   int compteur = 0;

   ---

   et
   
   Code:

   ---

   1 2	for(int i=0; i<num; i=i+1) { }

   ---

2. Ensuite côté algorithmique
   
   1. La boucle sur numlet : for (int numlet=0; numlet<14; numlet=numlet+1)Le but de cette boucle est de parcourir les lettres du mot. Tu décides arbitrairement que tous les mots font 14 lettres. Si ce n'est pas le cas, tu auras des erreurs d'exécution. Utiliser plutôt la longueur du mot, donc la taille du tableau unmot :
      for (int numlet=0; numlet<unmot.length; numlet=numlet+1)
   2. La boucle sur i : for(int i=0; i<num; i=i+1){La borne limite supérieure exclue pour i est num, quelque chose de défni par la boucle for (int num=0; num<1; num=num+1){, qui est juste une boucle qui va déterminer le nombre de fois qu'on tire un mot et qu'on compte le nombre de lettres. Quel sens cela peut avoir dans la notion de compter les lettres d'un mot ? Aucun ! Accesoirement, la boucle sur num ne sert pas à grand chose si tu ne changes pas la borne supérieure : on ne fait qu'une seule fois le calcul.
   3. Ensuite, pour compter le nombre de lettres, quelque soit les autres conditions, nécessite de parcourir tout le mot puis ensuite d'afficher le résultat.
      La notion de "lettres différentes" impose de comparer des lettres entre elles. Et de pouvoir savoir qu'une lettre a déjà été rencontrée ou pas. En plus, il ne faut compter une lettre si elle est différente des autres qu'une seule fois.
      Par exemple, dans le mot "rococo", il y a 3 lettres différentes. Le r, le o et le c.
   4. Il y a plusieurs façons de résoudre le problème, mais une des plus simple à mon avis est de faire :
      
      Code:

      ---

      1 2 3

      pour toutes les lettres du mot si la lettre est rencontrée pour la première fois on la stocke (autrement dit, si la lettre n'a pas déjà été rencontrée) fin pour

      ---

      A la fin on compte le nombre de lettres stockées et on a le nombre de lettres différentes.
      Donc voici pour commencer (avant de coder), des questions que tu dois te poser
      
      • comment stocker des lettres ? Sachant qu'une nouvelle lettre ne doit pas écraser une lettre déjà stockée.
      • comment savoir qu'une lettre a déjà été rencontrée ?
      • comment savoir le nombre de lettres stockées à la fin
   
   

Je vous remercie de votre réponse, malheureusement mes tentatives pour réaliser cet exercice restent vaines. Je vous envoie mon exercice modifié par votre aide.
Merci beaucoup pour vos nombreuses informations, mais hélas comme je suis débutant, j’ai du mal à vous suivre.
Faut-il faire un nouveau tableau*?

Commence par répondre à ces questions :

Citation:

---

Envoyé par joel.drigo

• comment stocker des lettres ? Sachant qu'une nouvelle lettre ne doit pas écraser une lettre déjà stockée.
• comment savoir qu'une lettre a déjà été rencontrée ?
• comment savoir le nombre de lettres stockées à la fin

---

Citation:

---

Envoyé par Chm412

Faut-il faire un nouveau tableau*?

---

Oui, c'est déjà bien : tu as répondu en partie à la première question ("Comment stocker des lettres ?"). On va utilser un tableau pour stocker les lettres du mots, afin de savoir celles qu'on a rencontrée. Le but est de les stocker chacune qu'une seule fois, afin d'avoir le nombre de lettres différentes.
Comment connaître la taille de ce tableau ? Et bien, dans le pire des cas, chaque lettre du mot sera présente qu'une seule fois dans le mot (donc toutes les lettres seront différentes). Il suffit donc que le tableau ait pour taille la taille du mot, qui est le plus grand nombre de lettres qu'on peut trouver dans le mot.
Donc tu peux commencer à écrire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class MotAuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); char[] lettres = new char[unmot.length]; // un tableau pôur stocker les lettres qu'on rencontre dans le mot for (int numlet=0; numlet<unmot.length; numlet=numlet+1) char c=unmot.charAt(numlet); // la lettre à la position numlet   } ] }

---

On va parcourir les lettres du mot (la boucle sur numlet). Pour chaque lettre, on va chercher dans le tableau lettres si elle s'y trouve déjà, si oui, on ne fait rien, sinon, on la stocke.

Donc, comment fait-on :

• pour mettre la lettre c dans le tableau lettres ?
• pour qu'à chaque nouvelle lettre, on n'écrase pas celles qui ont déjà été mises dedans ?

Et ensuite répondre aux deux autres questions précedemment posées...

J’ai Pu tester votre solution mais un problème m’empêche d’aller jusqu’au bout*: une erreur de déclaration de variable m’est signalée concernant cette ligne*:
char c = unmot.charAt(numlet); // la lettre à la position numlet

J’ai effectué plusieurs tests, et je pense que ça vient de mes déclarations de variables dans mes boucles for.
Faut-il que je mette if après char c = unmot.charAt(numlet);?

Citation:

---

Envoyé par Chm412

J’ai Pu tester votre solution mais un problème m’empêche d’aller jusqu’au bout*: une erreur de déclaration de variable m’est signalée concernant cette ligne*:
char c = unmot.charAt(numlet); // la lettre à la position numlet

J’ai effectué plusieurs tests, et je pense que ça vient de mes déclarations de variables dans mes boucles for.
Faut-il que je mette if après char c = unmot.charAt(numlet);?

---

Oups, c'est de ma faute : unmot n'est pas une String mais un tableau de char, donc c'est :

Code:

---

char c= unmot[numlet];

---

Bonjour monsieur, je passe mon examen vendredi après-midi, le problème est le suivant*: je n’ai pas le temps de chercher davantage sur cet exercice, les vidéos du mooc ne fonctionnent pas et je dois passer au dernier exercice nommé «*le pendu*», je vous remercie pour votre aide, qui m’a aidée à comprendre d’avantage ce magnifique langage qu’est le java, ainsi que le procédé qu’est la programmation.

Je ne m’en sors pas, Je pense que je dois refaire un tableau plus grand et lier les lettres à un tableau de chiffres plus grand pour ne pas écraser celles qui sont déjà dedans. Je pense que je dois aussi mettre un if, mais je n’ai pas la méthode pour compter.

Encore merci pour votre aide*

Citation:

---

Envoyé par Chm412

Je ne m’en sors pas, Je pense que je dois refaire un tableau plus grand et lier les lettres à un tableau de chiffres plus grand pour ne pas écraser celles qui sont déjà dedans. Je pense que je dois aussi mettre un if, mais je n’ai pas la méthode pour compter.

---

Non. Il suffit que le tableau ait la taille de unmot.
Si c, la lettre qu'on est en train de traiter est déjà dans le tableau, on ne fait rien, sinon on la stocke dans un emplacement libre. Comment avoir un emplacement libre ? Au début le tableau est vidfe. Donc si on a une variable nb qui vaut 0, on peut écrire lettres[nb]=c; qui stocke la lettre, puis on fait nb=nb+1; ce qui permet de passer à l'emplacement libre suivant pour le prochain coup. En plus nb est le nombre de lettres déjà stocker dans le tableau lettres.
Du coup, pour chercher si la lettre est déjà stocké, il suffit simplement de parcourir le tableau :

Code:

---

1 2 3 4 5

for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau } }

---

Donc, comme on veut savoir si la lettre est déjà présente ou absente, il faut un booléen pour stocker cette information, afin de la traiter.

Code:

---

1 2 3 4 5 6 7 8

boolean lettretrouve=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } }

---

Et donc comme on veut stocker la lettre si elle n'est pas déjà dans le tabelau, on va faire

Code:

---

1 2 3 4

if ( !lettretrouvee ) { lettres[nb]=c; nb=nb+1; }

---

Et comme nb c'est le nombre de lettres dans le tableau lettres, et bien, c'est aussi le nombre de lettres différentes dans le mot d'origine.

Au final

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

public class MotAuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); char[] lettres = new char[unmot.length]; // un tableau pour stocker les lettres qu'on rencontre dans le mot int nb=0; // au début on a stocké 0 lettre dans le tableau for (int numlet=0; numlet<unmot.length; numlet=numlet+1) { char c=unmot[numlet]; // la lettre à la position numlet // on cherche si c est dans lettre boolean lettretrouvee=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } } // si la lettre n'est pas dans le tableau lettres, on la met dans le prochain emplacement libre, et on passe à l'emplacement libre suivant if ( !lettretrouvee ) { lettres[nb]=c; // on la met dans le prochain emplacement libre nb=nb+1; // on passe à l'emplacement libre suivant } } // a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a " + nb + " lettre(s) différente(s) dans le mot "); } } }

---

Merci beaucoup à vous pour votre patience et vos explications détaillées qui me permettent de bien comprendre l'éxercice.
Mais, j'ai un petit soucis avec la fin car dans le résultat final le mot ne s'affiche pas, j'ai essayé de trouver mais je n'y suis pas arrivé.

Citation:

---

Envoyé par Chm412

j'ai un petit soucis avec la fin car dans le résultat final le mot ne s'affiche pas

---

Ton mot est un tableau de caractères (un char[]). Il y a plusieurs façons d'afficher un tableau :

1. faire une boucle, et afficher chaque élément
   
   Code:

   ---

   1 2 3

   for(int i=0; i<unmot.length; i++) { System.out.print(unmot[i)); }

   ---

2. utiliser la méthode Arrays.toString() pour transformer le tableau en String, pour pouvoir l'afficher
   
   Code:

   ---

   System.out.println(Arrays.toString(unmot));

   ---

   Mais comme cette méthode est prévue pour afficher un tableau, tu ne verras pas le mot, mais une suite de caracères séparés par des virgules, entouré de crochets

Pour un char[], une méthode simple est de créer un String à partir du char[] :

Code:

---

System.out.println( new String(unmot) );

---

Donc tu peux écrire :

Code:

---

1 2	// a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a " + nb + " lettre(s) différente(s) dans le mot "+new String(unmot)+".");

---

Ou encore :

Code:

---

System.out.format("Il y a %d lettre(s) différente(s) dans le mot %s.%n", nb, new String(unmot));

---

PS: je viens de me rendre compte qu'il y avait 2 fautes de frappe dans le code que je t'ai donné. J'ai corrigé dans le code.

[edit]tiens, en bonus, tu pourrais même écrire les lettres trouvées comme ça :

Code:

---

System.out.println("Il y a " + nb + " lettre(s) différente(s) ("+Arrays.toString(Arrays.copyOf(lettres, nb))+") dans le mot "+new String(unmot));

---

Cela fonctionne mais me donne un lettre en trop.

Exemple

> run MotAuSort
Il y a 9 lettre(s) différente(s) dans le mot PERSPECTIVE
>
J'ai essayé d'enlever "(.)" mais ça ne change rien.

Encore merci

Moi, quand j'exécute le code avec le mot PERSPECTIVE, ça m'affiche :

Il y a 8 lettre(s) différente(s) ([P, E, R, S, C, T, I, V]) dans le mot PERSPECTIVE.

Ce qui est le bon résultat.

C'est quoi le "(.)" ?

Recolle-moi le code que tu as, que je vois si tu as fait une erreur de copier/coller.

Code copié
}
// a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot
System.out.println("Il y a " + nb + " lettre(s) différente(s) dans le mot "+new String(unmot)+".");
}

"." cela dit avec ou sans cela ne change rien.

voici ce qui est affiché dans le correcteur automatique.

Echec

Erreur: Nombre de lettre incorrect: peut-être l'espace considéré compté comme une lettre Erreur: nombre de lettres incorrect au test 1 expected:<6> but was:<7>

Encore merci

Citation:

---

Envoyé par Chm412

Code copié
}
// a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot
System.out.println("Il y a " + nb + " lettre(s) différente(s) dans le mot "+new String(unmot)+".");
}

---

Je paralis de TOUT le code.

Citation:

---

Envoyé par Chm412

"." cela dit avec ou sans cela ne change rien.

---

Bah, forcément, c'est le . de fin de phrase (ponctuation), je ne vois pas ce que ça changerait à la valeur de nb, d'avoir un point, ou pas...

Citation:

---

Envoyé par Chm412

voici ce qui est affiché dans le correcteur automatique.

Echec

Erreur: Nombre de lettre incorrect: peut-être l'espace considéré compté comme une lettre Erreur: nombre de lettres incorrect au test 1 expected:<6> but was:<7>

---

Et c'est quoi le mot ?
Et çà "peut-être l'espace considéré compté comme une lettre", ça pourrait être intéressant, ne penses-tu pas ?

Par exemple*:
Agata = 1 mot de 5 lettres dont trois différentes*: le a le g et le t, le a se répète trois fois.

Ag atata = 2 mots séparés par un espace, je ne compte pas l’espace comme une lettre

Citation:

---

Envoyé par Chm412

Par exemple*:
Agata = 1 mot de 5 lettres dont trois différentes*: le a le g et le t, le a se répète trois fois.

---

Non, parce que A n'est pas a. Il y a donc 4 lettres dans ce mot. Tu n'as jamais dit que cela devait être sans tenir compte de la casse. Et en tout cas, pour ton exemple avec PERSPECTIVE, qui n'a que des lettres de même casse, il n'y a aucune raison de trouver 9 lettres.

Et tu es sûr de ça ? Tu dois savoir alors comment tester l'égalité d'une lettre quelque soit sa casse donc. Parce que, pour le coup, ce n'est plus un problème purement algorithmique comme jusqu'à maintenant, mais un problème avec une solution propre à Java.

Citation:

---

Envoyé par Chm412

Ag atata = 2 mots séparés par un espace, je ne compte pas l’espace comme une lettre

---

Ça, c'est la même chose : tu n'as jamais dit que unmot pouvait contenir plusieurs mots séparés par des espaces. Au contraire, unmot veut dire "un mot", un seul mot donc. D'où l'importance de choisir des noms de variable qui ont du sens à défaut de fournir des spécifications précises et complètes.

Pour faire ça il suffit d'exclure le traitement de l'espace quand on parcourt les lettres du mot. Ou autrement dit, de ne traiter que les caractères qui ne sont pas une espace.

Désolé,

Je voulais écrire AGATA .

Toutes les lettres du mot ont la même casse et le mot sans espaces entre les lettres.

Mais je ne comprends pas pourquoi le programme compte toujours une lettre en trop?

Exemple résultat affichage:

> run AuSort
Il y a 7 lettre(s) différente(s) dans le mot BENEFICE
>

> run AuSort
Il y a 8 lettre(s) différente(s) dans le mot NECESSAIRE
>

Si je teste le programme, j'obtiens :

Il y a 3 lettre(s) différente(s) ([A, G, T]) dans le mot AGATA.
Il y a 6 lettre(s) différente(s) ([B, E, N, F, I, C]) dans le mot BENEFICE.
Il y a 7 lettre(s) différente(s) ([N, E, C, S, A, I, R]) dans le mot NECESSAIRE.

Tu ne m'as toujours pas montré ton code...

Tu peux ajouter juste ça System.out.println("Mot saisi : " + Arrays.toString(unmot)); juste après char[] unmot = MOOC.motAuSort();. Exécuter et m'envoyer ce que ça affiche...

voici le code que j'ai copié.

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

public class AuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); char[] lettres = new char[unmot.length]; // un tableau pour stocker les lettres qu'on rencontre dans le mot int nb=0; // au début on a stocké 0 lettre dans le tableau for (int numlet=0; numlet<unmot.length; numlet=numlet+1) { char c=unmot[numlet]; // la lettre à la position numlet // on cherche si c est dans lettre boolean lettretrouvee=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } } // si la lettre n'est pas dans le tableau lettres, on la met dans le prochain emplacement libre, et on passe à l'emplacement libre suivant if ( !lettretrouvee ) { lettres[nb]=c; // on la met dans le prochain emplacement libre nb=nb+1; // on passe à l'emplacement libre suivant } } // a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a "+nb +" lettre(s) différente(s) dans le mot "+new String(unmot)); } } }

---

__________________________________________________________________

Voici ce qui s'affiche lorsque je mets la phrase System.out.println("Mot saisi : " + Arrays.toString(unmot));

> run AuSort
Il y a 10 lettre(s) différente(s) dans le mot CONSOLIDATION
Current document is out of sync with the Interactions Pane and should be recompiled!
>
Merci beaucoup,
Après je ne vous embèterai plus avec cela :)
>

Citation:

---

Envoyé par Chm412

Current document is out of sync with the Interactions Pane and should be recompiled!

---

ça veut dire que le fichier n'a été pas compilé.
As-tu ajouté l'import nécessaire ? (import java.util.Arrays;)

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

import java.util.Arrays; public class AuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); System.out.println("Mot saisi: "+Arrays.toString(unmot)); char[] lettres = new char[unmot.length]; // un tableau pour stocker les lettres qu'on rencontre dans le mot int nb=0; // au début on a stocké 0 lettre dans le tableau for (int numlet=0; numlet<unmot.length; numlet=numlet+1) { char c=unmot[numlet]; // la lettre à la position numlet // on cherche si c est dans lettre boolean lettretrouvee=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } } // si la lettre n'est pas dans le tableau lettres, on la met dans le prochain emplacement libre, et on passe à l'emplacement libre suivant if ( !lettretrouvee ) { lettres[nb]=c; // on la met dans le prochain emplacement libre nb=nb+1; // on passe à l'emplacement libre suivant } } // a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a "+nb +" lettre(s) différente(s) dans le mot "+new String(unmot)); } } }

---

Le soucis c'est que J'ai toujours une lettre en trop.



Welcome to DrJava. Working directory is /Users/papa/Desktop/lemotausort
> run AuSort
Mot saisi: [C, O, N, T, I, N, U, E, , , , , , ]
Il y a 8 lettre(s) différente(s) dans le mot CONTINUE
>

Citation:

---

Envoyé par Chm412

Le soucis c'est que J'ai toujours une lettre en trop.

---

Normal, rien a été changé au code à part un affichage...

Citation:

---

Envoyé par Chm412

Mot saisi: [C, O, N, T, I, N, U, E, , , , , , ]

---

Et dans cet affichage, on voit les différentes lettres du mot, et on voit qu'il y a des espaces à la fin du mot !!! Comme on traite les espaces, forcément, ils comptent pour une lettre de plus.

Je rappelle que j'ai écrit :

Citation:

---

Envoyé par joel.drigo

Pour [ne pas compter les espaces] il suffit d'exclure le traitement de l'espace quand on parcourt les lettres du mot. Ou autrement dit, de ne traiter que les caractères qui ne sont pas une espace.

---

Comment fait-on pour ne pas compter les espaces ? Et bien, on fait le comptage des lettres si c n'est pas une espace. Donc if ( c!=' ' ) {.

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

public class AuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); char[] lettres = new char[unmot.length]; // un tableau pour stocker les lettres qu'on rencontre dans le mot int nb=0; // au début on a stocké 0 lettre dans le tableau for (int numlet=0; numlet<unmot.length; numlet=numlet+1) { char c=unmot[numlet]; // la lettre à la position numlet if ( c!=' ' ) { // on ne compte pas les espaces // on cherche si c est dans lettre boolean lettretrouvee=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i++) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } } // si la lettre n'est pas dans le tableau lettres, on la met dans le prochain emplacement libre, et on passe à l'emplacement libre suivant if ( !lettretrouvee ) { lettres[nb]=c; // on la met dans le prochain emplacement libre nb=nb+1; // on passe à l'emplacement libre suivant } } } // a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a "+nb +" lettre(s) différente(s) dans le mot "+new String(unmot)); } } }

---

Je réussi à faire fonctionné de temps en temps le programme, et comme ultime vérification je l’ai passé au vérificateur du MOOC et voici le message qu’il me met.

Correcteur automatique de l'exercice (Ressource externe)

Echec
Erreur: Nombre de lettre incorrect: peut-être l'espace considéré compté comme une lettre Erreur: nombre de lettres incorrect au test 1 expected:<8> but was:<9>



Programme modifié. ( j'ai mis import java.util.Arrays;

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

import java.util.Arrays; public class AuSort{ public static void main(String[] args){ for (int num=0; num<1; num=num+1){ char[] unmot = MOOC.motAuSort(); char[] lettres = new char[unmot.length]; // un tableau pour stocker les lettres qu'on rencontre dans le mot int nb=0; // au début on a stocké 0 lettre dans le tableau for (int numlet=0; numlet<unmot.length; numlet=numlet+1) { char c=unmot[numlet]; // la lettre à la position numlet // on cherche si c est dans lettre boolean lettretrouvee=false; // au début on ne l'a pas trouvé, forcément, puisqu'on ne la pas encore cherchée for(int i=0; i<nb; i=i+1) { if ( lettres[i]==c ) { // la lettre est déjà présente, puisqu'on en trouve une égale dans le tableau lettretrouvee = true; // on stocke le fait qu'on l'a trouvée break; // ça, ça n'est pas indispensable, mais comme on a trouvé la lettre, pas la peine de continue à chercher, on peut s'arrêter donc ici. } } // si la lettre n'est pas dans le tableau lettres, on la met dans le prochain emplacement libre, et on passe à l'emplacement libre suivant if ( !lettretrouvee ) { lettres[nb]=c; // on la met dans le prochain emplacement libre nb=nb+1; // on passe à l'emplacement libre suivant } } // a la fin, le nombre de lettres stockées dans le tableau lettres est le nombre de lettres différentes du mot System.out.println("Il y a " + nb + " lettres différentes dans le mot "+new String(unmot)+"."); } } }

---

Super

Merci beaucoup pour votre précieuse aide et votre patience, qui m'ont permis de mieux comprendre les erreurs de mon programme et de valider cet exercice.

Je vous remercie de tout coeur et vous souhaite une bonne continuation.

Christian

:D

Citation:

---

Envoyé par Chm412

Programme modifié. ( j'ai mis import java.util.Arrays;

---

Inutile. C'était juste pour pouvoir faire System.out.println("Mot saisi: "+Arrays.toString(unmot)); pour savoir quelles lettres il y avait dans le mot. Ce n'est pas la peine de laisser ça, donc l'import non plus.

Citation:

---

Envoyé par Chm412

Echec
Erreur: Nombre de lettre incorrect: peut-être l'espace considéré compté comme une lettre Erreur: nombre de lettres incorrect au test 1 expected:<8> but was:<9>

---

Il doit y avoir un autre caractère à ne pas compter, ou un autre truc, mais comme je ne peux pas deviner les mots générés par ton truc et les caractères qu'il y a dans ces mots, qu'est-ce que tu veux que je te réponde ? A part que tu peux toi-même regarder les caractères qui sont comptés en trop et modifier le code pour que ça ne les compte pas. Après tout, tu as tout ce qu'il te faut maintenant pour le faire tout seul.
[edit] bah, maintenant tu dis que ça fonctionne... dionc c'est bone alors.