[C#] Method récursive ?

Version imprimable

Bonjour,

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

j'ai ceci
Code:

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:

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)

Voila où j'en suis :

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
 
        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:

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...

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:

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]) ; } }