Discussion :

[Anthares]

Bonjour à tous,

Je viens requérir votre aide car là, je n'ai vraiment aucune idée de comment résoudre mon problème .

Je vous explique le dit problème: pour les biens d'une application, je dois réussir à obtenir toutes les combinaisons possibles entre les éléments de 2 listes.
En image sa donne:

Liste 1: {toto, titi}
Liste 2: {tata, tutu}

Résultat: {{toto, tata}, {toto, tutu}, {titi, tata}, {titi, tutu}}

J'ai commencé à chercher, mais je dois avouer que l'algo ne me viens pas du tout , surtout, qu'au final, je dois trouver quelque chose de générique car je ne sais pas combien de listes j'aurais à utiliser .

Voilà, si vous avez une idée .

Merci de l'aide que vous pourrez m'apporter

[bibbi]

Salut,

Tu peux avoir un nombre de listes infini contenant un nombre d'éléments infini?

[Anthares]

Non, il y a tout de même une limite .

On a donc un maximum de 20 listes et de 30 items par liste.

[bibbi]

Et s'il y a plus de deux listes, il faut donner la combinaison de toutes les listes assemblées?

Genre:

liste1{a, b, c}
liste2{x, y, z}
liste3{1, 2, 3}

Résultat: {a, x, 1}, {a, x, 2}, {a, x, 3}, {a, y, 1} etc....

Ou bien toujours deux par deux?

Résultat: {a,x}, {a,y} {a, 1} {a,2} {x,1} ....

[Anthares]

Dans le cas de plusieurs listes, il faut obtenir ce résultat ci:

Genre:

liste1{a, b, c}
liste2{x, y, z}
liste3{1, 2, 3}

Résultat: {a, x, 1}, {a, x, 2}, {a, x, 3}, {a, y, 1} etc....

[bibbi]

Et tu fais la différence entre {a, 1, x} et {a, x, 1} par exemple?

Ou l'ordre n'a aucune importance?

[Anthares]

L'ordre n'a pas réellement d'importance, par contre, il ne faut qu'une occurrence de chaque liste donc {a, 1, x} = {a, x, 1}

[bibbi]

Bon j'ai réussi à faire un algo qui fait çà. Voilà le code:

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
43
44
45
46
47
48
49
50
51
 
 
 static List<string> listeCombinaisons = new List<string>();
 
        static void Main(string[] args)
        {
            List<string> liste1 = new List<string>();
            liste1.Add("a");
            liste1.Add("b");
            liste1.Add("c");
 
            List<string> liste2 = new List<string>();
            liste2.Add("1");
            liste2.Add("2");
            liste2.Add("3");
 
            List<string> liste3 = new List<string>();
            liste3.Add("x");
            liste3.Add("y");
            liste3.Add("z");
 
            List<List<string>> listeGlobale = new List<List<string>>();
            listeGlobale.Add(liste1);
            listeGlobale.Add(liste2);
            listeGlobale.Add(liste3);
 
            rempliListeCombinaison("", 0, listeGlobale);
 
            foreach (string s in listeCombinaisons)
            {
                Console.WriteLine(s);
            }
        }   
 
        static void rempliListeCombinaison(string str, int indexListe, List<List<string>> listeGlobale)
        {
 
            if (listeGlobale.Count > indexListe)
            {
                foreach (string s in listeGlobale[indexListe])
                {
                    str += s;
                    rempliListeCombinaison(str, indexListe + 1, listeGlobale);
                    str = str.Remove(str.Length - 1);
                }
            }
            else
            {
                listeCombinaisons.Add(str);
            }
        }

Normalement çà doit marcher pour un nombre infini de listes et un nombre infini de contenu. A toi d'adapter à ce que tu veux faire après

[Anthares]

Merci beaucoup, ça marche nickel .

Je suis en train de l'adapter pour obtenir une liste de liste d'objet en sortie au lieux d'une liste de string

[bibbi]

Il était vraiment intéressant à faire cet algo

Bien sûr si quelqu'un a mieux, je serai tout aussi intéressé qu'Anthares de le voir

[Nathanael Marchand]

Il était vraiment intéressant à faire cet algo

Bien sûr si quelqu'un a mieux, je serai tout aussi intéressé qu'Anthares de le voir

Code :

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

1
2
3
4
5
6
7
8
var l1 = new [] {"a","b","c"};
var l2 = new [] {1,2,3};
var l3 = new [] {"x","y","z"};
 
var result = from i1 in l1
	from i2 in l2
	from i3 in l3
	select new {i1,i2,i3};

[bibbi]

Ah oui j'avais pas pensé à utiliser çà. Vu que je développe sous le framework 2.0, j'ai pas le réflexe.

Merci de l'info C'est sûr que c'est beaucoup plus simple mais il faut au moins le framework 3.0 ou 3.5 il me semble.

[bibbi]

Code :

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

1
2
3
4
5
6
7
8
var l1 = new [] {"a","b","c"};
var l2 = new [] {1,2,3};
var l3 = new [] {"x","y","z"};
 
var result = from i1 in l1
	from i2 in l2
	from i3 in l3
	select new {i1,i2,i3};

Juste une question:

Comment fais tu pour un nombre de listes dynamique. Etant donné qu'il ne connait pas le nombre de listes à l'avance.

Parce-que dans ton code là, il me semble qu'on soit bloqué à trois liste. Tu peux créer la requête dynamiquement?

[Anthares]

Pourquoi faire simple quand on peut faire compliqué . En tout cas, ça marche nickel.

Merci

[Guulh]

Ce que tu cherches à faire, ça s'appelle un produit cartésien.

Une fois qu'on sait ça, un peu de google nous amène notamment ici, qui est une source d'info de premier ordre, Eric Lippert étant l'un des concepteurs de C#

[Nathanael Marchand]

A noter qu'il faut y aller molo avec les produits cartésiens! J'avais utilisé ca pour résoudre bêtement un sudoku. Ca marche mais c'est long. (Il y'avait environ 81 listes de 9items max (ce qui commence a faire pas mal de combinaisons).

[bibbi]

Ok merci pour l'info