Discussion :

[ChristopheQ]

Bonjour,

J'ai essayé de mettre un titre parlant mais pas facile
J'ai un souci de conception, n'étant pas très à l'aise avec les méthodes récursives. Vous allez comprendre.

J'ai, par exemple, 4 listes possédant chacune 2 nombres. Ce que je cherche à faire, c'est additionner (par exemple), chaque combinaison possible.

Exemple :

Liste A possède A0 et A1
Liste B possède B0 et B1
Liste C possède C0 et C1
Liste D possède D0 et D1

Je souhaite faire :
A0 + B0 + C0 + D0
A1 + B0 + C0 + D0
A0 + B1 + C0 + D0
...
A1 + B1 + C1 + D1

Voilà. Je ne dois pas être le premier au monde à vouloir faire ça .
Sachant que je la seule chose que je connaisse, c'est que mes listes ont un nombre identiques d'éléments, sinon il peut y avoir x listes de y éléments.

C'est forcément soluble avec une méthode récursive, encore faut-il la pondre

Si quelqu'un connait le principe ?

Merci.

Christophe

[pseudocode]

Tiens, voila le retour de la vengeance du fils du produit cartésien.

Au fait, pourquoi en récursif ? 4 boucles for() et c'est réglé, non ?

[ChristopheQ]

Je ne connais pas du tout Python, comment traduire l'exemple que vous me fournissez :

def main():
Tailles=[30,32]
Couleurs=['jaune','rouge','bleu']
Textures=['Jeans','Cuir']
print [[X,Y,Z] for X in Tailles for Y in Couleurs for Z in Textures]

if __name__ == '__main__':
main()



Par ailleurs, le problème est que je ne connais pas à l'avance le nombre de groupes de valeurs que j'aurais, ni le nombre de valeurs des groupes...

[Trap D]

Je ne connais pas Python, mais en Prolog ça donne çà :

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
add(L, LV) :-
	bagof(V, sum(L, V), LV).
 
 
sum([H], V) :-
	!,
	member(V, H).
 
sum([H | T], V1+V0) :-
	sum(T,V0),
	member(V1, H).
 
test(LV) :-
	Tailles=[30,32],
	Couleurs=['jaune','rouge','bleu'],
	Textures=['Jeans','Cuir'],
	add([Tailles, Couleurs, Textures ], LV).

Sortie:

7 ?- test(LV).
LV = [30+ (jaune+'Jeans'), 32+ (jaune+'Jeans'), 30+ (rouge+'Jeans'), 32+ (rouge+'Jeans'), 30+ (bleu+'Jeans'), 32+ (bleu+'Jeans'), 30+ (jaune+'Cuir'), 32+ (jaune+'Cuir'), 30+ (rouge+'Cuir'), 32+ (rouge+'Cuir'), 30+ (bleu+'Cuir'), 32+ (bleu+'Cuir')] ;
false.

[ChristopheQ]

Merci beaucoup pour votre réponse.
En fait j'avais oublié de préciser, je cherche un exemple en C# (ou Java à la rigueur).
Je suis en train d'étudier tous les exemples que j'ai pu trouver sur developpez, mais j'avoue avoir un peu de mal à transcrire le code Python que je trouve partout en c#.
Mais bon, je cherche, je cherche

[pseudocode]

En Java alors ?

Code java :

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
int N = 3;
int[][] E = new int[N][];
E[0] = new int[] {1,2,3};
E[1] = new int[] {40,50};
E[2] = new int[] {600,700,800,900};
 
int card = 1;
for(int i=0;i<N;i++)
	card*=E[i].length;
 
for(int k=0;k<card;k++) {
	int sum=0, value=k;
	for(int i=0;i<N;i++) {
		int q = value / E[i].length;
		int r = value % E[i].length;
		sum += E[i][r];
		value = q;
	}
	System.out.println(sum);
}

[ChristopheQ]

Ah là déjà ça me parle beaucoup plus

Je vais étudier cela !

Sinon j'étais en train de jeter un oeil là-dessus, avec Linq en C# 3 (mais je ne connais pas du tout) : http://blogs.msdn.com/mitsufu/archiv...binaisons.aspx

Merci encore pour votre aide (ces algos ne sont décidément pas ma tasse de thé ! )

Christophe

[ChristopheQ]

Bonjour

Ça fonctionne au poil ! J'étais en fait parti dans des trucs bien plus compliqués. Comme quoi la simplicité fait beaucoup.
Ça me rappelle les propos d'un collègue qui souhaitait évaluer le temps de développement en fonction du nombre de lignes de codes Encore un exemple qui prouve que ça n'a rien à voir et que c'est même beaucoup plus souvent l'inverse !!!

Merci encore.

Christophe