Aide pour définir des poules à partir de combinaisons

Version imprimable

1 pièce(s) jointe(s)

Bonjour, je suis débutant j'aurais besoin d'un petit coup de pouce s'il vous plait.

J'ai cherché longtemps sans succès j'espère que quelqu'un connait la solution.
J'ai réussi à faire des combinaisons pour des matchs pour un projet de tournoi de cartes (magic pour les intimes :) )
voilà mon code python
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 import itertools Liste_de_joueurs = ['J1','J2','J3','J4','J5','J6'] Matchs_possibles = list(itertools.combinations(Liste_de_joueurs, 2)) print(Matchs_possibles) """[('J1', 'J2'), ('J1', 'J3'), ('J1', 'J4'), ('J1', 'J5'), ('J1', 'J6'), ('J2', 'J3'), ('J2', 'J4'), ('J2', 'J5'), ('J2', 'J6'), ('J3', 'J4'), ('J3', 'J5'), ('J3', 'J6'), ('J4', 'J5'), ('J4', 'J6'), ('J5', 'J6')] """ Session 1 = [] #Par exemple J1 vs J2, J3 vs J4, J5 vs J6 Session 2 = [] Session 3 = [] Session 4 = [] Session 5 = []
Le soucis est que je n'arrive pas à créer des sessions en mettant les tuples (match) dans les listes afin d'avoir des phases de duels entre les joueurs sans répétition (c'est à dire que chaque joueur aura un match différents par session. Je met le code en image en pièce jointe si besoin,
Puissiez vous me venir en aide :roll ::)
Pièce jointe 580947

Je te propose ça mais il y aura mieux avec les habitués de ce forum :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import random
 
liste_de_joueurs = ['J1','J2','J3','J4','J5','J6']
 
def creer_session(liste):
    rand = random.sample(liste,6)
    return [(i,rand[rand.index(i)+1]) for i in rand if rand.index(i)%2==0]
 
 
while len(liste_de_joueurs): #A changer ?
    session = creer_session(liste_de_joueurs)
    '''... la suite de ton code ...'''
    for perdant in perdants: #Il te faudrait créer une liste où tu y mets les perdants
        liste_de_joueurs.remove(perdant)

Code:

1
2
>>> session
[('J1', 'J5'), ('J4', 'J6'), ('J3', 'J2')]

08/10/2020, 07h32
Sinbad93

1 pièce(s) jointe(s)

Les sessions ne s'excluent pas

Bonjour LeNarvalo,
Un grand merci à toi pour ton aide.
Effectivement cela fonctionne pour créer des sessions de jeu mais les sessions ne s'excluent toujours pas.
C'est à dire que plusieurs joueurs jouent deux fois de suites contre le même adversaire alors qu'étant 6 joueurs, ils sont censés pouvoir faire 5 sessions contre un joueur différents à chaque fois.
Pour le moment j'ai essayé comme ça sans me préoccuper de la boucle while et voilà les résultats pour 5 sessions.
Pièce jointe 580964

Comme on peut le voir les sessions sont indépendantes les unes des autres et ne s'excluent pas.
Donc ce n'est pas encore opérationnel. 8O
Je ne dois pas être le premier à créer un appli de tournoi :D je ne comprends pas pourquoi je ne trouve pas l'information.
Quelqu'un connait la solution ?
08/10/2020, 08h59
josmiley

Faut découper la liste une fois mélangée.
08/10/2020, 09h12
Sinbad93

Oui merci, je sais, d'ailleurs c'est bien pour ça que j'ai crée une liste avec des tuples de tous les matchs possible, il est évident qu'il faut la découper pour créer ensuite les différentes sessions. Mais voilà je n'arrive pas à la découper pour obtenir 5 sessions différentes sans doublons de matchs....

ha je vois, les joueurs ne jouent qu'une fois par poule ... donc ma solution n'est pas bonne.

comme ça ?

Code:

1
2
3
4
5
6
7
8
9
10
11
from random import shuffle
 
p1 = [('j1','j2'),('j4','j5'),('j3','j6')]
p2 = [('j1','j3'),('j2','j4'),('j5','j6')]
p3 = [('j1','j4'),('j2','j6'),('j3','j5')]
p4 = [('j1','j5'),('j2','j3'),('j4','j6')]
p5 = [('j1','j6'),('j3','j4'),('j2','j5')]
 
for p in (p1,p2,p3,p4,p5):
    shuffle(p)
    print(p)

08/10/2020, 12h47
Sinbad93

Ce n'est pas adaptable en fonction du nombre de joueurs

Merci Josmiley,
C'est l'idée et ce que je finirais pas faire au pire mais ce n'est pas très pratique.
Si ton appli est créée pour 6 joueurs et que tu as 4 participants le jour J ou 10 ?
C'est pourquoi je cherche à créer un fonction ou une formule qui sera adaptable directement au nombre de participants, et pas devoir modifié le code le jour du tournoi.
08/10/2020, 18h51
Invité
Hum c'est plus compliqué que ce que je pensais ce truc...

Un exemple de truc que j'ai :
Code:

1 2 3 4 5 [('J3', 'J5'), ('J6', 'J4'), ('J1', 'J2']) [('J3', 'J2'), ('J6', 'J1'), ('J4', 'J5')] [('J3', 'J1'), ('J6', 'J2')] [('J3', 'J4'), ('J6', 'J5')] [('J3', 'J6'), ('J1', 'J5'), ('J4', 'J2')]
En faite dans la session n°3, si J3 joue contre J1 et J6 contre J2 alors J4 doit jouer contre J5 sauf qu'il a déjà fait ce match ! :calim2:

Je vais continuer à réfléchir !
08/10/2020, 21h25
Sinbad93

Merci Narvalo,
Oui je m'attaque a un gros morceau j'ai l'impression.
J'ai trouvé ça : http://www.echecs.asso.fr/LivreArbit...re_arbitre.pdf
à la page 53 il y a une formule pour faire les appariement.
Mais même là il y a une exception dans la formule si le joueur est le numéro n, ou n étant le nombre total de participant.
C'est le principe de la table de berger.
Enfin bref pour l'instant je continue à essayer 8-)
08/10/2020, 23h14
josmiley

je n'ai toujours pas trouvé de logique de tri ...

hello,

Citation:

Envoyé par Sinbad93

J'ai cherché longtemps sans succès j'espère que quelqu'un connait la solution.

as-tu cherché chez nos amis les angliches ?
J'ai trouvé chez eux une discussion intéressante ici
Ton problème ressemble à celui des tournois toutes rondes (round-robin tournament).
I y a plusieurs algorithmes pour le résoudre dont le Circle method et le Berger tables
Dans la discussion il y a un code en python qui utilise des conteneurs deque se comportant comme une liste avec des ajouts et retraits rapides à chaque extrémité.
Voici le code en python 3 :
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 from collections import deque from itertools import islice def fixtures(teams): if len(teams) % 2: teams.append("Bye") ln = len(teams) // 2 dq1, dq2 = deque(islice(teams, None, ln)), deque(islice(teams, ln, None)) for _ in range(len(teams)-1): yield list(zip(dq1, dq2))# list(zip.. python3 # pop off first deque's left element to # "fix one of the competitors in the first column" start = dq1.popleft() # rotate the others clockwise one position # by swapping elements dq1.appendleft(dq2.popleft()) dq2.append(dq1.pop()) # reattach first competitor dq1.appendleft(start) joueurs = ["J1", "J2", "J3", "J4", "J5", "J6"] i=1 for session in list(fixtures(joueurs)): print('session' + str(i) + ' : ' + str(session)) i+=1
et voici le résultat :

Citation:

session1 : [('J1', 'J4'), ('J2', 'J5'), ('J3', 'J6')]
session2 : [('J1', 'J5'), ('J4', 'J6'), ('J2', 'J3')]
session3 : [('J1', 'J6'), ('J5', 'J3'), ('J4', 'J2')]
session4 : [('J1', 'J3'), ('J6', 'J2'), ('J5', 'J4')]
session5 : [('J1', 'J2'), ('J3', 'J4'), ('J6', 'J5')]

Ami calmant, J.P

09/10/2020, 10h23
Sinbad93

On y est

Super ça à l'air d'être ce que je cherche !!
Merci beaucoup Jurassik Pork :D
Par contre je ne sais pas ce que sont des conteneurs "deque" ? enfin ne t'embête pas je ferais ma petite recherche :)
Je test ça demain (aujourd'hui je travaille sur du html) et si tout est ok, pas d'autre blocage, je confirme la résolution.
Effectivement j'aurais du mieux chercher en essayant de taper "combinaisons list" + "round-robin", mais je ne savais pas que ça s'appelait comme ça il y encore 2 jours :oops:
Merci, bonne journée :zoubi:

EDIT : ça marche super, résolu.
Un grand Merci à tous.

Tournoi round robin, toutes rondes, codage, programmation.
10/10/2020, 13h25
josmiley

je me suis creusé la tête, et j'ai pas trouvé mieux que du A* en algo, et c'est vraiment très long.

Autre possibilité

Merci quand même Josmiley :zoubi:

Pour info une autre solution qui m'a été proposé (plus courte aussi):
(Cette fois ci en cas de nombre impair le match qui se joue pas n'apparait simplement pas, mais la variante est bien gérée)
Code:

1 2 3 4 5 6 7 8 def tournament_sessions(n): sessions, players = [], list(range(1, n + 1)) for _ in range(n - 1): sessions.append([(players[i], players[-i-1]) for i in range(n // 2)]) players[1:] = players[-1:] + players[1:-1] return sessions print(tournament_sessions(6))