Discussion :

[marco10024]

Bonjour à tous, voici mon problème :

j'ai un tableau à n cellules qui contiennent elles mêmes n valeurs.
ex :

Code :

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

1
2
3
4
5
6
tab = (
            taille  ( 30, 32 ),
            couleur ( jaune, rouge, bleu, vert, .... ), 
            texture ( jeans, cuir, ... ), 
            .....  
         )

Et je veux récupère chaque combinaison possible :

Code :

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

1
2
3
4
5
6
res = (
            (30, jaune, jeans),
            (30, jaune, cuir), 
            (30, rouge, jeans),
            ...
         )

Si quelqu'un a une idée, je suis preneur car je coince vraiment là

merci

[PRomu@ld]

Il s'agit d'un problème d'énumération, ça n'est pas très compliqué. Un enchaînement de boucle devrait suffire.

Par ex :

Code :

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

1
2
3
4
5
6
7
8
 
Pour i de 1 à NbTaille faire 
     Pour j de 1 à NbCouleur faire 
          Pour k de 1 à NbTexture faire 
              Combinaison <- ( i-ème taille , j-eme couleur , k-ème texture ) 
          Fin pour   
     Fin pour
Fin pour

Sinon, tu peux procéder autrement en remplissant les combinaisons au fur et à mesure un peu à la manière d'un compteur.

Tu commences par calculer le nombre de combinaisons (un simple produit), et ensuite pour chacune de tes cellules, tu remplies. Par ex imagines que tu ne travailles que sur deux catégories, la taille (39 et 40) et la couleur (en supposant trois couleurs : rouge jaune et bleu). Ca te fait donc 6 combinaisons possibles, tu commences à remplir le premier champ :

( 39 , X )
( 39 , X )
( 39 , X )
( 40 , X )
( 40 , X )
( 40 , X )

C'est simple, le premier champ, tu sais que tu dois prendre en compte toutes les combinaisons et tu sais que tu n'as que deux choix possibles, il y a donc trois combinaisons avec 39 et trois avec 40.

Ensuite, pour la deuxième case, il suffit de ne travailler que sur un intervalle du précédent (par ex les trois premières combinaisons), les autres tu vas les obtenir en répétant ce que tu viens de calculer.

( 39 , Rouge )
( 39 , Jaune )
( 39 , Bleu )

Pour obtenir les trois autres combinaisons, il te suffit de copier ce que tu viens de faire.

Ca se généralise en dimensions n sans trop de problèmes.

[marco10024]

Oui c'est simple évidement si on connais le nombre de dimensions.

2 dimensions : 2 boucles for, 3 dimensions : 3 boucles for...

Mais ce que je n'arrive pas, c'est à mettre en place un script qui fonctionne avec 1 ou n dimensions.

[PRomu@ld]

Utilises alors la seconde solution que je t'ai proposé.

[Zavonen]

La solution se trouve dans mon cours (Relations->produits cartésiens).
Voilà l'algo en python:

Code python :

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
# -*- coding: latin-1 -*-
from sets import Set
import copy
 
#construction du produit cartésien par deux boucles imbriquées
def cartesien (E,F):
    P=[]
    while E:
        x=E.pop()
        G=copy.copy(F)#car la boucle suivante est destructrice
        while G:
            y=G.pop()
            c=[x,y]
            C=[c]
            P.extend(C)
    return P
 
#isomorphisme (A,(B,C)) (A,B,C)
def flat (L):
    return L[1]+[L[0]]
 
def main():
    Tailles=[30,32]
    Couleurs=['jaune','rouge','bleu']
    Textures=['Jeans','Cuir']
    C1=cartesien(Couleurs,Textures)
    C2=cartesien(Tailles,C1)
    print [flat(X) for X in C2]
 
if __name__ == '__main__':
    main()

[ToTo13]

Bonjour,

tu connais forcément le nombre d'éléments puisque tu les as stocké
Donc tu fais un parcours récursif sur tous tes éléments => un appel récursif qui ne contient qu'une boucle.