Discussion :

[Ticoche]

Bonjour,

J'aimerai développer une méthode me permettant de "distribuer" des voyelles dans une liste... mais je bloque !

j'ai ceci

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
        enum Voyelles
        {
            A = 0,
            E = 1,
        }
 
 
            List<String> lstTest = new List<String>();
            lstTest.Add("B");
            lstTest.Add("C");
            lstTest.Add("D");

J'aimerai obtenir en sortie une List<List<String>> qui aurait comme listes :

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
 
 
            List<List<String>> sortie = new List<List<string>>();
            List<String> lst1 = new List<String>();
            lst1.Add("B");
            lst1.Add("C");
            lst1.Add("D");
            lst1.Add("A");
 
            List<String> lst2 = new List<String>();
            lst1.Add("B");
            lst1.Add("C");
            lst1.Add("A");
            lst1.Add("D");
            lst1.Add("A");
            //...
            sortie.Add(lst1);
            sortie.Add(lst2);
            //...

De tel sorte que l'enum (les voyelles) forme toutes les combinaison possible, sauf qu'une voyelle doit être à coté de consonnes (ou une seule si en bout de chaîne), autrement dit il ne doit pas y avoir 2 voyelles à coté.

Voici un exemple de résultat :

BCDA
BCADA
BACADA
ABACADA
BCDE
BCADE
BCADE
BACADE
ABACADE
...
BCAD
BACAD
ABACAD
BCED
BACED
ABACED
...
BACD
ABACD
EBACD
BECD
ABECD
EBECD
...
ABCD
EBCD
(il n'y a pas toutes les combinaisons dans cet exemple)

Chaque ligne représente une Liste<String> où chaque lettre est dans un String. (j'ai volontairement simplifier mon problème)

Si vous avez des pistes à me donner ? J'ai commencé une méthode récursive mais je n'arrive pas au bon résultat.

Merci

édit: attention, ma liste de départ peut contenir de 1 à N élément (beaucoup)

[Ticoche]

Voila où j'en suis :

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
 
        private List<List<string>> maMethode(List<string> lstTest)
        {
            List<List<string>> locale = new List<List<string>>();
            List<List<string>> localeBis = new List<List<string>>();
            List<string> copie = new List<string>(lstTest);
            int capa = lstTest.Count;
 
            for (int i = 0; i < capa+1; i++)
            {
                locale.Add(new List<string>(lstTest));
 
            }
 
            foreach (var item in locale)
            {
                foreach (Voyelles v in Enum.GetValues(typeof(Voyelles)))
                {
                    List<string> tmp = new List<string>(copie);
                    tmp.Insert(capa, v.ToString());
                    localeBis.Add(tmp);
                }
                capa--;
            }
 
            locale.Clear();
            foreach (var item in localeBis)
            {
                locale.Add(item);
            }
 
            return locale;
        }

C'est pas très jolie pour le moment j'obtiens une partie du résultat :

Code :

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

1
2
3
4
5
6
7
8
9
 
BCDA
BCDE
BCAD
BCED
BACD
BECD
ABCD
EBCD

il me manque tous les résultats avec 2 voyelles ou plus...

[Graffito]

Je ne suis pas sur d'avoir bien compris le problème, mais ceci pourra te donner des pistes.

Objectif de la procédure récursive :
A partir d'un résultat "Mot" de N lettres, ajoutons au résultats l'ensemble des string de N+1 lettres obtenus en ajoutant à "Mot" une lettre de plus.
Les conditions à respecter étant :
- si la dernière lettre de Str est une voyelle, on ne pourra ajouter qu'une consonne,
- les lettres qui peuvent être ajoutées ne doivent pas être dèjà contenues dans Mot.

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
 
int n  = 7 ; // nombre de lettres maxi des mots 
string Consonnes = "ABCDFG" ;
string Voyelles = "AEI" ;
List<String> Resultats = new List<String>() ;
Build("") ;
 
internal void Build(Mot String)  // La procédure récursive
{   // ajout de consonnes
  for (j=0;j<Consonnes.Length;j++) if (Mot.IndexOf(Consonnes[j]<0) 
  {
     Resultats.Add(Mot+Consonnes[j]) ;
     if (Mot.Length<n) Build(Mot+Consonnes[j]) ; 
  }
  // ajouts de voyelles
  if (Voyelles.IndexOf(Resultats[i][Mot.Length-1])<0) 
  for(j=0;j<Voyelles.Length;j++) if (Mot.IndexOf(Voyelles[j]<0) 
  {
     Resultats.Add(Mot+Voyelles[j]) ;
     if (Mot.Length<n) Build(Mot+Voyelles[j]) ; 
  }
}