Discussion :

[childof]

voici le code que j'ai envisagé.

celui-ci est court et a simplement pour but de donner toutes les solution d'arrangement de "o" lettre parmis "n" (les lettres sont considérées en ordre croissant.)

voici le code que j'utilise :

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
/**
 * 
 * @author (laurent)
 * @version (avril 2007)
 */
class ls
{ 
 
  public static void main()
    { // main
        int o=3;//nobre de tirages
        char n='d'; // ensemble de départ
        int temp;
        int tmp;
        long tot=0; // compteur
 
        char[] tab1= new char[4];
        for (int i=0; i<tab1.length; i++){
            tab1[i] = 'a';
        }
        char[] tab2= new char[4];
        for (int j=0; j<tab2.length; j++){
            tab2[j] = 'd';
        }
        while(tab1!=tab2){
            temp=tab1[o];
            tab1[o]=(char)temp++;
            for(int k=o;k<=0;k--){
                if(tab1[k]>n){
                    tab1[k]='a';
                    tmp=tab1[k-1];
                    tab1[k-1]=(char)(tmp++);
                }//fin if
            }//fin for
            System.out.println(tab1);
             tot=tot+1;
}//fin while
        System.out.println("");
        System.out.println("FIN ("+tot+" résultats trouvés");
 
    } // main
} // class

la problème, est que celui qui fait une boucle infinie et afiche sans cesse

aaaa
aaaa
...

quelqu'un voit il mon erreur?

merci à vous

[Sanguko]

Quelques remarques :

for (int i=0; i<tab1.length; i++){
tab1[i] = 'a';
}

se remplace par

Code :

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

Arrays.fill(tab1,'a');

while(tab1!=tab2){

n'a aucune chance d'etre vrai

temp=tab1[o];
tab1[o]=(char)temp++;

est equivalent a

Code :

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

tab1[o] = (char) (tab1[o]+1)

Par contre, je ne vois pas du tout quel est le resultat attendu

[JMLLB]

quelqu'un voit il mon erreur?

de laquelle tu parles?

Pour info la récursivité n'a rien a voir avec ton problème (ta méthode ne s'appelle pas elle-même!).

Citation:
while(tab1!=tab2){

n'a aucune chance d'etre vrai

pas de bol! ça à toutes les chances d'être vrai, et c'est même tout le temps vrai!
Comme tu ne rentres jamais dans ta boucle for (k<=0 avec k=o=3) tu ne modifies pas tab1 (enfin pas dans la tranche 0..2). Et donc si tab1!=tab2 est vrai une fois, c'est vrai tout le temps puisque tu ne modifie pas non plus tab2.

donc...tu ne sort jamais de ta boucle donc:
aaa
aaa
aaa
...

tu y tiens vraiment à ta variable o? parceque déjà des variables d'une lettre c'est pas folichon (encore que i,j,k pour des compteurs de boucle ça va) mais la franchement ça ressemble trop à 0 pour être honnête.

Sinon si tu préfère faire simple, mais je n'ai peut être pas compris ce que tu voulais faire:
une table lettres de quatre chars initialisés dans l'ordre à 'a','b','c' et 'd'
trois boucles for imbriquées avec i,j,k comme compteurs de boucle et

Code :

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

System.out.println(lettres[i]+lettres[j]+lettres[k]);

ça t'évite les décrementations, les tests d'arrêts, l'arithmétique sur les chars, les casts et les variables temporaires superflues.

[childof]

JMLLB : j'ai fait commùe sa au debut, mais le but est que cela fonctinne avec n et o variable et le rpoblème est que sinon j'ai des

for(...)

for(....)

for(...)

.....

en tout cas merci pour les remarque.

pour la recusivité, je parle de récusivité mathématique


le resutat attendu est :

aaaa
aaab
aaac
aaad
aaba
aabb
aabc
aabd
aaca
....

[JMLLB]

pour la recusivité, je parle de récusivité mathématique

Ah! d'accord maintenant c'est plus clair!

Non, sans rire, la récursivité c'est la récursivité, mathématique ou pas!

Bon maintenant que je comprend mieux ce que tu veux faire, la manière la plus simple de traiter ton pb est effectivement la recursivité.

Mais ce n'est pas du tout ce que tu fais pour l'instant.
Il faut que tu définisses une méthode qui va s'appeler elle même.

du genre:

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
void traitementRecursif(
  int profondeurCourante_in,
  int profondeurMax_in,
  int nbLettresDistinctes_in,
  String mot_in){
  if (profondeurCourante_in<=profondeurMax_in){
    for(int i=0;i<nbLettresDistinctes_in;i++){
      this.traitementRecursif(
        profondeurCourante_in+1,
        profondeurMax_in,
        nbLettresDistinctes_in,
        mot_in+this.lettres[i]);
     }
   }else{
     System.out.println(mot_in);
   }
}

tu n'as plus qu'à appeler cette méthode dans ton main.

Généralement lorque l'on peut éviter la récursivité on préfère. C'est plus simple à coder qu'une solution itérative pure, mais en terme de performance ce n'est pas compétitif.

[sinok]

En java, sur les dernières versions de la JVM c'est tangeant car le compilo r"alise de optis sur tout ce qui est récursivité, et en général j'ai tendance à préférer un code synthétique et propre qu'une horreur de bidouille itérative. (et de toute façon dès que tu bosses sur des arbres de décision, du backtrack & cie... l'itératif n'est pas envisageable)