itertools combinations -- tirage au sort pour un double mixte

Version imprimable

Bonjour,

Connaissant les règles suivantes:
- double mixte
- 5 parties à disputées
- un homme ne peut jouer qu´une seule fois avec la même partenaire
- un couple ne peut rencontrer et jouer qu´une seule fois contre le(s) même(s) adversaire(s)

je cherche à effectuer un tirage au sort pour l´organisation d´un double mixte. J´ai réussi en passant par la génération d´un tableau ou j´élimine les tuples (paires/paires et impaires/impaires).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola","Soazic","Nolwenn","Birgit"] NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel","Marcus","Alexander"] nbjoueur=len(NomFemme)+len(NomHomme) from itertools import combinations A=list(combinations(list(range(1,nbjoueur)),2)) lenA=len(A)-1 while lenA!=-1: B=list(A[lenA]) if B[0]%2 != 0 and B[1]%2 != 0: del A[lenA] if B[0]%2 == 0 and B[1]%2 == 0: del A[lenA] lenA-=1 print("Liste des couples:",A) print("Nombre de couples",len(A))
voyez-vous de l´optimisation avant que je poursuive?

Cordialement,

26/03/2018, 18h58
wiztricks

Salut,

Citation:

Envoyé par 2e8b92

voyez-vous de l´optimisation avant que je poursuive?

C'est relativement simple de sortir le tirage du premier tournoi.
Après, pour les autres conditions, il va falloir se rappeler qui a joué avec qui, contre qui,...
Difficile de ne pas construire cet historique sans structurer au minimum ses données.
"optimiser" sera une question à vous poser lorsque vous aurez un premier code fonctionnel: avant, çà sera encore trop le chantier.

- W

Bonjour,

le "chantier" est de retour avec un code non fonctionnel (et j´aimerais bien savoir pourquoi): "list index out of range", 1 fois sur 2-3
une idée?

merci par avance

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
##############################################################################
# initialisation
##############################################################################
NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola","Soazic","Nolwenn","Birgit"]
NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel","Marcus","Alexander"]
NbPlayer=len(NomFemme)+len(NomHomme)
TennisPlace = int(NbPlayer / 4)
NbExempt = NbPlayer - TennisPlace * 4
ExemptF = len(NomFemme) - TennisPlace * 2
ExemptH = len(NomHomme) - TennisPlace * 2
print("NbPlayer",NbPlayer,"nbFemme",len(NomFemme),"nbHomme",len(NomHomme),"TennisPlace",TennisPlace,"NbExempt",NbExempt,"ExemptF",ExemptF,"ExemptH",ExemptF)
##############################################################################
# Création de toutes les paires mixtes de joueurs
##############################################################################
from itertools import combinations
A=list(combinations(list(range(1,NbPlayer+1)),2))
lenA=len(A)-1
while lenA!=-1:
    B=list(A[lenA])
    if B[0]%2 != 0 and B[1]%2 != 0:
        del A[lenA]
    if B[0]%2 == 0 and B[1]%2 == 0:
        del A[lenA]
    lenA-=1
#print("Liste des couples:",A)
print("Nombre de couples",len(A))
##############################################################################
# round01
##############################################################################
round01=[]
from random import randint
# Tirage au sort du premier couple (H/F)
hasard=randint(0,len(A))
B=A[hasard]
round01.append(B[0])
round01.append(B[1])
#print("B",B)
del A[hasard]
#print("round01",round01)
#print("Nombre de couples",len(A))
#
for i in range(1,TennisPlace*2):
    hasard=randint(0,len(A))
# Tirage au sort du couple (H/F) suivant
    C=A[hasard]
    print(len(A), C, hasard)
    while B[0] in C or B[1] in C or C[0] in round01 or C[1] in round01:
        hasard=randint(0,len(A))
        C=A[hasard]
#        print("C",C,"hasard",hasard,"count",len(A),"i",i)
    if B[0] in C or B[1] in C:
        print("doublon")
    else:
        round01.append(C[0])
        round01.append(C[1])
        del A[hasard]
        B = C
print("round01",round)
print("Nombre de couples restant",len(A))

28/03/2018, 22h59
wiztricks

Citation:

Envoyé par 2e8b92

le "chantier" est de retour avec un code non fonctionnel (et j´aimerais bien savoir pourquoi): "list index out of range", 1 fois sur 2-3
une idée?

L'instruction "print" devrait vous permettre de voir dans quelles conditions çà pète.
Puis vous relisez la documentation de random.randint pour vous assurer que vous l'utilisez correctement ou s'il n'y a pas une fonction plus appropriée.
note: du code qui plante, c'est pas un algo.

- W

salut à tous,

qui peux me dire pourquoi ai-je des doublons? merci par avance

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
 
##############################################################################
# Check Adversaire
##############################################################################
def CheckAdversaire(Trouve,MyList01,MyList02):
    Trouve=False
    nb=0
    while nb<16:
        if MyList02[nb] not in MyList01:
            pass
        else:
            MyVal=MyList01.index(MyList02[nb])
            if MyVal in [0,4,8,12]:
                decalage=2
            if MyVal in [1,5,9,13]:
                decalage=1
            if MyVal in [2,6,10,14]:
                decalage=-2
            if MyVal in [3,7,11,15]:
                decalage=-3
            pos01=MyVal+decalage
            pos02=MyVal+decalage+1
            if nb in [0,4,8,12]:
                if MyList02[nb+2]==MyList01[pos01] or MyList02[nb+2]==MyList01[pos02] or MyList02[nb+3]==MyList01[pos01] or MyList02[nb+3]==MyList01[pos02]:
                    Trouve=True
                    return Trouve
            if nb in [1,5,9,13]:
                if MyList02[nb+1]==MyList01[pos01] or MyList02[nb+1]==MyList01[pos02] or MyList02[nb+2]==MyList01[pos01] or MyList02[nb+2]==MyList01[pos02]:
                    Trouve=True
                    return Trouve
            if nb in [2,6,10,14]:
                if MyList02[nb-1]==MyList01[pos01] or MyList02[nb-1]==MyList01[pos02] or MyList02[nb-2]==MyList01[pos01] or MyList02[nb-2]==MyList01[pos02]:
                    Trouve=True
                    return Trouve
            if nb in [3,7,11,15]:
                if MyList02[nb-2]==MyList01[pos01] or MyList02[nb-2]==MyList01[pos02] or MyList02[nb-3]==MyList01[pos01] or MyList02[nb-3]==MyList01[pos02]:
                    Trouve=True
                    return Trouve
        nb+=1
    return Trouve
##############################################################################
# initialisation
##############################################################################
#NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola","Soazic","Nolwenn","Birgit"]
#NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel","Marcus","Alexander"]
NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola","Soazic"]
NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel"]
NbPlayer=len(NomFemme)+len(NomHomme)
TennisPlace = int(NbPlayer / 4)
NbExempt = NbPlayer - TennisPlace * 4
ExemptF = len(NomFemme) - TennisPlace * 2
ExemptH = len(NomHomme) - TennisPlace * 2
print("NbPlayer",NbPlayer,"nbFemme",len(NomFemme),"nbHomme",len(NomHomme),"TennisPlace",TennisPlace,"NbExempt",NbExempt,"ExemptF",ExemptF,"ExemptH",ExemptF)
##############################################################################
# Création de toutes les paires mixtes de joueurs
##############################################################################
from itertools import combinations
A=list(combinations(list(range(1,NbPlayer+1)),2))
lenA=len(A)-1
while lenA!=-1:
    B=list(A[lenA])
    if B[0]%2 != 0 and B[1]%2 != 0:
        del A[lenA]
    if B[0]%2 == 0 and B[1]%2 == 0:
        del A[lenA]
    lenA-=1
#print("Liste des couples:",A)
#print("Nombre de couples",len(A))
##############################################################################
# rounds
##############################################################################
from random import *
MaListe=[]
RoundToPlay,k=0,0
Trouve=False
while RoundToPlay < 5:
    Couple=0
    C=[]
    while Couple < TennisPlace*2:
        hasard=randrange(0,len(A))
        B=A[hasard]
        while B[0] in MaListe or B[1] in MaListe:
            k+=1
            if k > 3000:
                break
            hasard=randrange(0,len(A))
            B=A[hasard]
        MaListe.append(B[0])
        MaListe.append(B[1])
        C.append(A[hasard])
        del A[hasard]
        Couple+=1
##############################################################################
# test si un joueur a déjà eu le(s) même(s) adversaire(s)
##############################################################################
    if RoundToPlay == 0:
        round01=MaListe
        MaListe=[]
    if RoundToPlay == 1:
        round02=MaListe
        MaListe=[]
        MyList01=round01
        MyList02=round02
#        print("round01",round01,"round02",round02)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
    if RoundToPlay == 2:
        round03=MaListe
        MaListe=[]
        MyList01=round01
        MyList02=round03
#        print("round01",round01,"round03",round03)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round02
        MyList02=round03
#        print("round02",round02,"round03",round03)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
    if RoundToPlay == 3:
        round04=MaListe
        MaListe=[]
        MyList01=round01
        MyList02=round04
#        print("round01",round01,"round04",round04)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round02
        MyList02=round04
#        print("round02",round02,"round04",round04)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round03
        MyList02=round04
#        print("round03",round03,"round04",round04)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
    if RoundToPlay == 4:
        round05=MaListe
        MaListe=[]
        MyList01=round01
        MyList02=round05
#        print("round01",round01,"round05",round05)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round02
        MyList02=round05
#        print("round02",round02,"round05",round05)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round03
        MyList02=round05
#        print("round03",round03,"round05",round05)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        MyList01=round04
        MyList02=round05
#        print("round04",round04,"round05",round05)
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
    if Trouve==False:
        RoundToPlay+=1
    else:
        A.extend(C)
##############################################################################
# affichage
##############################################################################
#print("Nombre de couples restants",len(A),"Liste des couples restants:",A)
round01.sort()
round02.sort()
round03.sort()
round04.sort()
round05.sort()
print("round01",list(set(round01)))
print("round02",list(set(round02)))
print("round03",list(set(round03)))
print("round04",list(set(round04)))
print("round05",list(set(round05)))

02/04/2018, 17h59
wiztricks

Citation:

Envoyé par 2e8b92

qui peux me dire pourquoi ai-je des doublons? merci par avance

Expliquez d'abord l'algorithme utilisé et comment est-ce qu'il garanti qu'il n'y a pas de doublons. Cela un peu plus clair, on pourra s'étonner, comme vous, que çà sorte des doublons et voir comment a été codé l'algo. avec Python.

- W

bonjour W,

Allons-y étape par étape, voici la 1ère partie de mon code:
- J´ai 2 listes femmes (x8) et hommes (x8),
- je calcule le nombre de personnes dans les 2 listes (x16)
- je génère toutes les combinaisons (tuples) possibles (x120) et j´élimine les paires-paires ou impaires-impaires (x56), il me reste (x64) paires

qu´en pensez-vous? (je ne vois pas mon erreur si erreur il y a)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola"] NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel"] NbPlayer=len(NomFemme)+len(NomHomme) # from itertools import combinations A=list(combinations(list(range(1,NbPlayer+1)),2)) lenA=len(A)-1 while lenA!=-1: B=list(A[lenA]) if B[0]%2 != 0 and B[1]%2 != 0: del A[lenA] if B[0]%2 == 0 and B[1]%2 == 0: del A[lenA] lenA-=1

Jusque là, je suis.
Ce que je ferais pour ma part :

Code:

1
2
3
4
5
6
from itertools import combinations
A=list(combinations(list(range(1,NbPlayer+1)),2))
B=[]
for elem in A:
    if (elem[0]%2!=0 and elem[1]%2!=1) or (elem[0]%2!=1 and elem[1]%2!=0):
        B.append(elem)

ou en plus rigolo :

Code:

1
2
3
4
5
6
from itertools import combinations
A=list(combinations(list(range(1,NbPlayer+1)),2))
B=[]
for el1,el2 in A:
    if el1%2 != el2%2:
        B.append((el1,el2))

03/04/2018, 10h01
wiztricks

Salut,

Citation:

Envoyé par 2e8b92

qu´en pensez-vous? (je ne vois pas mon erreur si erreur il y a)

Je ne pense rien, vous ne dites même pas pourquoi vous faites cela.
Et si je puise dans mes souvenirs au début, on crée des équipes de 1H x 1F.
Des solutions vous ont été suggérées pour faire cela...
Si maintenant vous faites autre chose, on peut supposer que ces solutions avaient des défauts qu'il serait bon de connaître - histoire de mieux comprendre ce que vous voulez - ou que le problème à changé.

note: pour fabriquer les 64 couples 8*H x 8*F, une double boucle suffit pour tous les construire. Pas besoin de créer un gros tas à réduire ensuite.

- W

Bonjour Marco056,

merci pour votre aide.

je continue avec la 2nde étape de mon code: "génération d´une partie"
- je tire au sort un couple de joueurs dans la liste précédemment construite A, jusqu´au remplissage des courts de tennis disponibles (ici x4) par couples
- je remplit B en séparant les couples et en rejetant les doublons
- je remplit en parallèle C (pour m´en servir plus tard)
- je supprime les couples au fur et à mesure de A

ceci est ma méthode, quelle est la votre Marco056?
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 NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola"] NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel"] NbPlayer=len(NomFemme)+len(NomHomme) TennisPlace = int(NbPlayer / 4) NbRound=5 # from random import * RoundToPlay=0 Trouve=False while RoundToPlay<NbRound: MaListe=[] Couple=0 C=[] while Couple<TennisPlace*2: hasard=randrange(0,len(A)) B=A[hasard] while B[0] in MaListe or B[1] in MaListe: hasard=randrange(0,len(A)) B=A[hasard] MaListe.append(B[0]) MaListe.append(B[1]) C.append(A[hasard]) del A[hasard] Couple+=1

03/04/2018, 12h50
marco056

Ce code tourne en boucle, non ? RoundToPlay ne change pas où c'est moi ?
Sinon, pour commencer, je ne comprends pas à quoi correspondent les lettres : c'est quoi A ? La liste des couples ? Autant lui donner un nom significatif : liste_couples ?
Ensuite, je ne sais pas ce qu'est B. Pourquoi s'intéresser à B[0] et B[1] ?*
Que sont C, MaListe, RoundToPlay ?
J'avoue que j'ai du boulot en ce moment : je ne pourrai pas m'y pencher davantage avant demain soir.

Bonsoir Marco056,

- en fait j´incrémente RoundToPlay un peu plus loin dans mon code (cette variable varie de 0 à NbRound, soit 5).
- Comme indiqué, j´ai remplacer A par liste_couples pour une meilleur comprehension. (le choix des lettres est purement arbitraire et basique. Je comptais suivre votre idée lorsque mon code serait devenu fonctionnel, mais vous avez raison, plus de clarté est meilleur).
- B est la facon que j´ai trouvé pour diviser le tuple en unité afin de tester si l´un ou l´autre des membres du tuple est déjà présent dans MaListe(un joueur ne peut pas jouer simultanément).
- J´ai testé sans succès "while B in MaListe or B[::-1] in MaListe:"
- C est une liste que je remplis et qui me servira plus tard. Si la condition est remplie, je supprime C, sinon je ré-injecte C dans liste_couples
- MaListe est une liste temporaire qui se remplie avec des tuples / chiffres uniques

dites moi si vous souhaitez voir le code en entier.
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 NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola"] NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel"] NbPlayer=len(NomFemme)+len(NomHomme) TennisPlace = int(NbPlayer / 4) NbRound=5 # from random import * RoundToPlay=0 Trouve=False while RoundToPlay<NbRound: MaListe=[] Couple=0 C=[] while Couple<TennisPlace*2: hasard=randrange(0,len(liste_couples)) B=liste_couples[hasard] while B[0] in MaListe or B[1] in MaListe: # while B in MaListe or B[::-1] in MaListe: # print(B,B[::-1],MaListe) hasard=randrange(0,len(liste_couples)) B=liste_couples[hasard] MaListe.append(B[0]) MaListe.append(B[1]) C.append(liste_couples[hasard]) del liste_couples[hasard] Couple+=1

Non, je ne veux pas voir le code et je ne vais pas faire l'exo non plus.
Est-ce que le programme suivant affiche ce que tu veux ?

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
34
35
36
NomFemme = ["Susanne","Isabelle","Annaig","Jaqueline","Svenja","Heide","Sabine","Carola"]
NomHomme = ["Frank N.","Stephane","Thomas","Jochen","Frank S.","Bernd","Paul","Marcel"]
NbPlayer=len(NomFemme)+len(NomHomme)
 
from itertools import combinations
A=list(combinations(list(range(1,NbPlayer+1)),2))
B=[]
for el1,el2 in A:
    if el1%2 != el2%2:
        B.append((el1,el2))
print(B)
liste_couples = B[:]
 
TennisPlace = 4
 
import random
Trouve=False
 
MaListe=[]
Couple=0
C=[]
while Couple<TennisPlace*2:
    hasard=random.randrange(0,len(liste_couples))
    print(hasard)
    B=liste_couples[hasard]
    print(B)
    while B[0] in MaListe or B[1] in MaListe:
        hasard=random.randrange(0,len(liste_couples))
        B=liste_couples[hasard]
    MaListe.append(B[0])
    MaListe.append(B[1])
    C.append(liste_couples[hasard])
    del liste_couples[hasard]
    Couple+=1
 
print(MaListe)

Si la réponse est non, il faut peut-être encore décomposer, user et abuser des" print" pour comprendre ce qui se passe.

Bonjour,

Afin d´éviter une méprise, cet exo n´en ai pas un mais plutôt le projet du club de tennis dont je suis joueur. Je dois préparer un tournoi de double mixte convivial suivant les règles ci-dessous:
- double mixte
- 5 parties à disputées
- un homme ne peut jouer qu´une seule fois avec la même partenaire
- un joueur ne peut rencontrer et jouer qu´une seule fois contre le(s) même(s) adversaire(s)

De plus, j´ajoute pratiquement un print partout pour mes tests (et je les enlève avant de copier mon code sur ce site).

Je continue avec la 3ème portion de mon code

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
##############################################################################
# test si un joueur a déjà eu le(s) même(s) adversaire(s)
##############################################################################
    if RoundToPlay == 0:
        round01=MaListe
##############################################################################
# test les parties 1 et 2
##############################################################################
    if RoundToPlay == 1:
        round02=MaListe
        MyList01=round01
        MyList02=round02
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
##############################################################################
# test les parties 1, 2 et 3
##############################################################################
    if RoundToPlay == 2:
        round03=MaListe
        MyList01=round01
        MyList02=round03
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        if Trouve == False:
            MyList01=round02
            MyList02=round03
            Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
##############################################################################
# test les parties 1, 2, 3 et 4
##############################################################################
    if RoundToPlay == 3:
        round04=MaListe
        MyList01=round01
        MyList02=round04
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        if Trouve == False:
            MyList01=round02
            MyList02=round04
            Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
            if Trouve == False:
                MyList01=round03
                MyList02=round04
                Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
##############################################################################
# test les parties 1, 2, 3, 4 et 5
##############################################################################
    if RoundToPlay == 4:
        round05=MaListe
        MyList01=round01
        MyList02=round05
        Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
        if Trouve == False:
            MyList01=round02
            MyList02=round05
            Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
            if Trouve == False:
                MyList01=round03
                MyList02=round05
                Trouve=CheckAdversaire(Trouve,MyList01,MyList02)
                if Trouve == False:
                    MyList01=round04
                    MyList02=round05
                    Trouve=CheckAdversaire(Trouve,MyList01,MyList02)

MaListe est générée avec le code précédant, quant à la fonction CheckAdversaire, j´utilise 'index'.
Je l´ai construite de manière à n´avoir 'que' le nombre de passage minimum (exemple: 16 joueurs, 16 passages)
y aurait il une autre méthode / fonction pour optimiser cette portion?

En fait, la règle la plus prenante en temps de traitement est incluse dans cette 3ème portion ('un joueur ne peut rencontrer et jouer qu´une seule fois contre le(s) même(s) adversaire(s)') et plus précisément dans la partie 'test les parties 1, 2, 3, 4 et 5'.

Merci par avance pour vos suggestions, en attendant, je poursuis ma lente progression.

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
34
35
def CheckAdversaire(Trouve,MyList01,MyList02):
    Trouve=False
    PosElement=0
    while PosElement<TennisPlace*4:
        if MyList02[PosElement] not in MyList01:
            pass
        else:
            MyVal=MyList01.index(MyList02[PosElement])
            if MyVal in [0,4,8,12,16,20]:
                decalage=2
            if MyVal in [1,5,9,13,17,21]:
                decalage=1
            if MyVal in [2,6,10,14,18,22]:
                decalage=-2
            if MyVal in [3,7,11,15,19,23]:
                decalage=-3
            pos01=MyVal+decalage
            pos02=pos01+1
            if PosElement in [0,4,8,12,16,20]:
                pos03=PosElement+2
                pos04=pos03+1
            if PosElement in [1,5,9,13,17,21]:
                pos03=PosElement+1
                pos04=pos03+1
            if PosElement in [2,6,10,14,18,22]:
                pos03=PosElement-1
                pos04=pos03-1
            if PosElement in [3,7,11,15,19,23]:
                pos03=PosElement-2
                pos04=pos03-1
            if MyList02[pos03]==MyList01[pos01] or MyList02[pos03]==MyList01[pos02] or MyList02[pos04]==MyList01[pos01] or MyList02[pos04]==MyList01[pos02]:
                Trouve=True
                return Trouve
        PosElement+=1
    return Trouve

05/04/2018, 11h02
wiztricks

Citation:

Envoyé par 2e8b92

Merci par avance pour vos suggestions, en attendant, je poursuis ma lente progression.

Si vous ne commencez pas par décrire (en français) l'algorithme que vous essayez de réaliser, pas grand monde aura le temps (et le courage) de décoder vos lignes de code. Et le saucissonner avec des commentaires qui n'ajoutent pas grand chose à ce qu'on peut lire n'aide en rien.

- W
05/04/2018, 11h40
2e8b92

salut W

j´essai de nouveau d´expliquer ce que je cherche à atteindre.

J´ai le projet du club de tennis dont je suis joueur de préparer un tournoi de tennis suivant les règles ci-dessous:
(1) double mixte (H/F)
(2) 16 joueurs minimum
(3) 5 parties à disputées
(4) un joueur ne peut jouer qu´une seule fois avec la / le même partenaire
(5) un joueur ne peut rencontrer et jouer qu´une seule fois contre le(s) même(s) adversaire(s)

Ma méthode utilisée avec Python
- Fonction 'PairesMixtes' pour générer la liste des combinaisons H/F sans doublons : règle (4) ci dessus
- Fonction 'CheckAdversaire' : règle (5) ci-dessus
- Corps du code qui gère les règles (1), (2) et (3)
- La règle (3) utilise la Fonction 'CheckAdversaire' qui vérifie à partir de la partie n°2 la validité de la règle (5)

La description est elle suffisante et claire pour vous W?
05/04/2018, 12h09
wiztricks

Citation:

Envoyé par 2e8b92

La description est elle suffisante et claire pour vous W?

Ben, cela:

Citation:

Envoyé par 2e8b92

J´ai le projet du club de tennis dont je suis joueur de préparer un tournoi de tennis suivant les règles ci-dessous:
(1) double mixte (H/F)
(2) 16 joueurs minimum
(3) 5 parties à disputées
(4) un joueur ne peut jouer qu´une seule fois avec la / le même partenaire
(5) un joueur ne peut rencontrer et jouer qu´une seule fois contre le(s) même(s) adversaire(s)

sont des exigences, i.e. un objectif à atteindre, des contraintes que devra respecter la solution.

Puis vous passez directement à la construction d'une solution:

Citation:

Envoyé par 2e8b92

Ma méthode utilisée avec Python
- Fonction 'PairesMixtes' pour générer la liste des combinaisons H/F sans doublons : règle (4) ci dessus
- Fonction 'CheckAdversaire' : règle (5) ci-dessus
- Corps du code qui gère les règles (1), (2) et (3)
- La règle (3) utilise la Fonction 'CheckAdversaire' qui vérifie à partir de la partie n°2 la validité de la règle (5)

sans expliquer pourquoi il faut la construire comme çà et encore moins en quoi elle va permettre d'obtenir le résultat.
Déjà, si vous constituez des équipes mixtes, pour arriver à tester les conditions 4 et 5, il faut qu'un certain nombres d'équipes s'affrontent. Ce qui va éventuellement produire pour chaque joueur deux listes: il a joué avec et il a joué contre qui.
C'est peut être à partir de là qu'il faut constituer les équipes et les rencontres de la deuxième étape (où peut être faire autre chose).
Et si vous ne prenez pas le temps de préciser ces détails, vous pouvez toujours coder ce qui vous passe dans la tête mais pas le partager.

- W
05/04/2018, 12h43
2e8b92

l´objectif à atteindre est maintenant clair pour vous, ouf...

quant la construction de 'ma' solution Python, ce n´est que l´illustration du point ou je suis rendu et uniquement fourni comme example.

J´ai déjà suivi plusieurs approches
- généré la 1ère partie sans doublons avec des couples H/F (que ce soit en VB sous excel ou avec Python, cela fonctionne)
à partir de la 2nde partie, je diffère dans les 2 languages:
- VB Excel
je tire au sort un couple et test s´ils n´ont pas déjà jouer ensemble
je tire au sort le couple suivant et test s´ils n´ont pas déjà jouer ensemble, et en plus s´ils ne sont pas déjà pas joués contre dans une précédante partie.
et ainsi de suite...
- Python
je génère la partie suivante en piochant dans la liste des couples sans doublons
je test pour tous les couples si l´un des joueurs n´a pas déjà eu le(s) même(s) adversaire(s)
et ainsi de suite...

Basé sur mes expériences VB excel et Python, à partir de la génération de la partie 4, le temps de traitement va devenir exponentiel

Votre méthode, si j´ai bien compris consiste à remplir 2 listes 'joue_avec' et 'joue_contre_qui' dès la 1ère partie / 1er couple tiré au sort, correct?
05/04/2018, 13h03
wiztricks

Citation:

Envoyé par 2e8b92

J´ai déjà suivi plusieurs approches

Supposons que ce que vous appelez "approche" pourrait s'appeler algorithme.

Citation:

Envoyé par 2e8b92

Votre méthode, si j´ai bien compris consiste à remplir 2 listes 'joue_avec' et 'joue_contre_qui' dès la 1ère partie / 1er couple tiré au sort, correct?

J'essaie juste de "reformuler" le problème i.e. le traduire avec des mots à moi, histoire de vous montrez quelque chose pour que vous puissiez dire: c'est çà ou ah non tu as oublié que...
Et pour ce que j'en ai compris, il y a des joueurs, des joueuses et des matches entre les différentes équipes construites à l'étape N.
Pour passer à l'étape N+1, il faut construire de nouvelles équipes vérifiant (4) et choisir des paires d'équipes qui vont jouer l'une contre l'autre (combien?) en respectant (5).
Et on recommence 5 fois (3).

Cela écrit, je raconte le déroulé (enfin ce qe j'en ai compris) des opérations sans m'être avancé sur l'algorithme/approche.
Pour sûr que pour respecter les conditions si on ne sait pas à N+1 qui a joué avec qui et qui a joué contre qui, çà va être impossible. Donc il faut bien le "matérialiser" d'une façon ou d'une autre: vous proposez quoi?

- W
05/04/2018, 17h19
2e8b92

Ma proposition est la suivante:
- conserver la fonction pour générer tous les couples H/F. Démarrer avec un capital de 17 joueurs (0 à 16 -- les chiffres paires pour les hommes et impaires pour les femmes, soit 72 combinaisons sans doublons possible).
- créer 2 tableaux 'joue_avec' et 'joue_contre_qui'
- tirer au sort le 1er tuple
- remplir les 2 tableaux 'joue_avec' et 'joue_contre_qui'
- tirer au sort le 2nd tuple
- vérifier que les nombres du 2nd tuple ne sont pas déjà utilisés dans les tableaux 'joue_avec' et 'joue_contre_qui', si trouvé tirer un nouveau tuple ou bien continuer avec le 3ème tuple
- remplir les 2 tableaux 'joue_avec' et 'joue_contre_qui'
- à partir du 4ème tuple (et ce tous les tuples paires), vérifier les tableaux 'joue_avec' et 'joue_contre_qui' si les conditions sont respectées
- arrivé au 8ème tuple, compléter la partie 1
- à partir du 9ème, refaire la même procédure qu´à partir du 1er tuple
- et ainsi de suite...jusqu´au remplissage des parties 1 à 5

et vous que feriez-vous?
05/04/2018, 17h43
wiztricks

Citation:

Envoyé par 2e8b92

et vous que feriez-vous?

Ma proposition est la suivante:
- conserver la fonction pour générer tous les couples H/F. Démarrer avec un capital de 17 joueurs (0 à 16 -- les chiffres paires pour les hommes et impaires pour les femmes, soit 72 combinaisons sans doublons possible).
- créer 2 tableaux 'joue_avec' et 'joue_contre_qui'

Jusque là pourquoi pas sinon que 17 joueurs par équipe de 2 c'est déjà un soucis qui pourrait être traité plus tard...
Puis:
- tirer au sort le 1er tuple
- remplir les 2 tableaux 'joue_avec' et 'joue_contre_qui
'
On peut tirer au sort une équipe (H, F) mais on ne va pas savoir contre qui elle va jouer.
Pourquoi ne pas dire: "on tire au sort 8 équipes de (H, F)" ce seront des tuple. Puis on organise un certain nombre (toujours non défini!!!) de matchs entre les équipes (ce qui fait un deuxième tirage au sort et des tuples d'équipes).
Ce n'est qu'après qu'on va pouvoir renseigner les informations "a joué avec" et "a joué contre" (quelque soit la forme choisie pour représenter çà).

Et maintenant on peut recommencer sauf que maintenant les informations "a joué avec" et "a joué contre qui" ne sont plus vides.
Donc "construire les équipes" et "choisir celles qui jouent contre qui" sera un peu plus compliqué.

- W
08/04/2018, 09h51
2e8b92

salut W,

Je re-formule ce que j´ai compris:
- conserver la fonction pour générer tous les couples H/F sans doublons 'liste_couples'.
- créer les tableaux 'avec_qui', 'contre_qui' et 'parties'
- créer une fonction 'génération_partie' (sans possibilités pour un joueur de jouer 2 fois) incluant un tableau temporaire 'MaListe'
- créer une fonction 'remplir_contre_qui'
- créer une fonction 'verifier_contre_qui'

Mes données de départ: 17 joueurs (il y aura un exempté à chaque tours) -- 5 parties à jouer (soit 8 équipes par tours)

Jusqu´ici, c´est bon pour moi,

Citation:

Envoyé par wiztricks

On peut tirer au sort une équipe (H, F) mais on ne va pas savoir contre qui elle va jouer.
Pourquoi ne pas dire: "on tire au sort 8 équipes de (H, F)" ce seront des tuple.

Ensuite je décroche, par rapport à ce que j´ai formulé ci-dessus, que voulez-vous dire?

Citation:

Envoyé par wiztricks

Puis on organise un certain nombre (toujours non défini!!!) de matchs entre les équipes (ce qui fait un deuxième tirage au sort et des tuples d'équipes).

Sinon le reste est claire pour moi,

Citation:

Envoyé par wiztricks

Ce n'est qu'après qu'on va pouvoir renseigner les informations "a joué avec" et "a joué contre" (quelque soit la forme choisie pour représenter çà).
Et maintenant on peut recommencer sauf que maintenant les informations "a joué avec" et "a joué contre qui" ne sont plus vides.
Donc "construire les équipes" et "choisir celles qui jouent contre qui" sera un peu plus compliqué.

Salut,

Citation:

Envoyé par 2e8b92

Ensuite je décroche, par rapport à ce que j´ai formulé ci-dessus, que voulez-vous dire?

Citation:

Envoyé par wiztricks

Puis on organise un certain nombre (toujours non défini!!!) de matchs entre les équipes (ce qui fait un deuxième tirage au sort et des tuples d'équipes).

Si on a 8 équipes, on peut organiser 4 matchs 2 contre 2, ou 7 matchs 2 contre les autres. A ce moment là, le deuxième tour devient impossible à faire puisque tout le monde aura joué contre tout le monde.

Citation:

Envoyé par 2e8b92

Mes données de départ: 17 joueurs (il y aura un exempté à chaque tours) -- 5 parties à jouer (soit 8 équipes par tours)

Vous essayez de construire un algorithme et le code associé qui vous permettra de...
Et dans "construire", il y a la définition des étapes qui vous permettront de travailler plus confortablement sur les différents aspects du problème.
Donc commencer par 2 x 4 joueurs, puis généraliser à 2 x 8 puis ajouter des exemptés pourrait être payant pour ne pas vous faire déborder immédiatement par la complexité des choses.

Citation:

Envoyé par 2e8b92

Je re-formule ce que j´ai compris:
- conserver la fonction pour générer tous les couples H/F sans doublons 'liste_couples'.
- créer les tableaux 'avec_qui', 'contre_qui' et 'parties'
- créer une fonction 'génération_partie' (sans possibilités pour un joueur de jouer 2 fois) incluant un tableau temporaire 'MaListe'
- créer une fonction 'remplir_contre_qui'
- créer une fonction 'verifier_contre_qui'

Au final, il faudra bien écrire du code, mais pour l'instant, on ne sait trop rien de ses différents composants sinon qu'il faut créer des équipes puis il faut qu'elles se rencontrent donc il faut créer des matchs/rencontres entre ces équipes et qu'à la fin il faut retenir qui à joué avec qui et qui a joué contre qui pour en tenir compte à l'étape suivante.
On peut ré-écrire tout çà sous la forme:
Code:

1 2 3 4 5 for x in range(4): équipes = équipes_créer(hommes, femmes, à_joué_avec) matchs = matchs_créer(équipes, à_joué_contre) à_joué_avec_mettre_à_jour(à_joué_avec, équipes) à_joué_contre_mettre_à_jour(à_joué_contre, matchs)
mais comme vous n'avez toujours pas d'algo. çà n'avance à pas grand chose car la structure changera probablement en fonction de celui-ci.

- W