Salut,
bon j'ai une petite question de logique/calcul.
 
Mise en situation :
Dans le cadre d'un tournois, on a un certain nombre de participant. Chacun des participant doit affronter tous les autres participant.
Le tournois se décompose donc en sessions au cours desquelles se déroule un certain nombre de match.
 
Exemple :
Participant : A, B, C, D et E.
 
Session 1 :
A affronte B
C affronte D
E ne joue pas.
 
Session 2 :
E Affronte D
C Affronte B
A ne joue pas.
 
Session 3 :
A affronte E
B affronte D
C ne joue pas.
 
Et ainsi de suite jusqu'à ce que tout le monde ait affronter tout le monde.
 
Ce que j'aimerais calculer c'est le temps qu'il faut prévoir pour le déroulement du tournois sachant qu'on connaît la durée de chaque match et la durée du temps qu'il y a entre chaque session.
 
Où qu'j'en suis :
Je sais qu'on peut calculer le nombre de match à réaliser ainsi, enfin ça me semble correcte :
Soit x le nombre de participant : TotalMatch = x*(x-1) Edit : En fait non faut aussi diviser par 2 donc : TotalMatch = x*(x-1)/2
 
D'autre part je sais qu'on peut approcher le nombre de sessions ainsi :
Soit x le nombre de participant : nbSession = TotalMatch/(x/2)
 
Donc en supposant qu'un match dure 20 minutes et qu'entre chaque session il y a 10 minutes on peut approcher la durée totale ainsi :
DureeTotaleEnMinutes = nbSession*20+(nbSession-1)*10
Enfin il me semble...
 
Ce qui ne va pas dans mes calcules c'est que je n'ai qu'une approche du nombre de sessions, donc je n'ai rien d'exacte au niveau de la durée totale.
Et franchement je sèche sur le calcul exacte du nombre de sessions, donc si quelqu'un a une idée : je suis preneur!
 
En vous remerciant.
 
-------------------------
Nouvelle question
Tant que j'y suis, je pose une nouvelle question :
Comment calculer correctement une session? C'est à dire qu'avec 6 participants je me retrouve bien avec 5 sessions. Parce que pour le moment je me retrouve avec plus que ça...
 
Ce que je fais :
Bon déjà j'ai une fonction MatchPlayed, qui retourne un booléen indiquant si oui ou nom le match a déjà été joué. De même, j'ai une fonction InSession.
 
Ca donne donc quelque chose comme ça :

 
C'est, en gros ce que fait mon code sauf que ça me donne pas le bon nombre de sessions. Par exemple la ça m'en donne 6.

Si le nombre d'equipes est pair, chaque equipe va rencontrer successivement toutes les autres, donc va faire x-1 match (et pareil pour les autres simultanément).
 
Si le nombre d'equipes est impair, il y aura en plus un match ou l'equipe n'aura pas d'amis, donc on en rajoute un, cela donne en résumé :
 
nombre_sessions = x - 1 +x%2
duree_totale = temps_discours_du_debut + nombre_sessions * (temps_match+temps_pause) - temps_pause + temps_faire_la_fête

Oui c'est aussi la théorie que j'avais imaginé... Mais :
Je me suis amusé à faire un petit tableau de correspondance entre nbParticipant, nbSession et pour 6 participant je trouve 7 sessions. Sauf que d'après ce que tu donne je devrais trouver 5 sessions.

Le soucis c'est qu'à un moment je me retrouve toujours avec des participant qui ont des match à jouer avec d'autres participant qui sont déjà pris par d'autres match dans la même session. Les match qui pourraient être joués avec les autres participant libres ont déjà étés joués.

Peut être que je calcul mal mes sessions...

Edit :
Voilà le tableau en question, je sais pas vraiment s'il est exacte. Je l'ai réalisé armé d'un papier et d'un stylo.

---------------------------
| NbParticipant | NbSession |
 ---------------------------
|        2          |      1        |
 ---------------------------
|        3          |      3        |
 ---------------------------
|        4          |      3        |
 ---------------------------
|        5          |      6        |
 ---------------------------
|        6          |      6        | // Edit2: Réussit à réduire à 6
 ---------------------------

Edit3 : Bon en fait pour 6 participant je trouve bien 6 sessions et non pas 7 qui était finalement une erreur.

pour 5 je trouve bien 5 :
A - BC - DE
B - AD - CE
C - AE - BD
D - AC - BE
E - AB - CD
pour 6 je trouve 5 aussi forcément (en rajoutant F a chaque fois avec celui qui était seul ):
AF - BC - DE
BF - AD - CE
CF - AE - BD
DF - AC - BE
EF - AB - CD

Une équipe ne joue qu'un seul match par session (j'aurais dû le préciser), c'est essentiel. Surtout pour que le calcul de la durée totale tienne la route, tel que tu l'as donné.
Et dans ce que tu viens de donner, dans les deux, B joue deux match dans la première session.

C'était une typo en recopiant mon tableau, quand tu remplace par E c'est bon et y'a aucun conflit

Effectivement, ya le bon nombre de match, tous les match et aucun conflit. C'est donc faisable en 5 sessions.
Bon et bien merci! Et désolé pour les contradictions.
 
Maintenant va falloir que je contrôle l'algo qui calcul chaque session, histoire de voir si le tournois se déroule avec le bon nombre de session. Sinon j'aurais l'air un peu con avec mes prévisions non respectées par mon soft.

Tant que j'y suis, je pose une nouvelle question :
Comment calculer correctement une session? C'est à dire qu'avec 6 participants je me retrouve bien avec 5 sessions. Parce que pour le moment je me retrouve avec plus que ça...

Ce que je fais :
Bon déjà j'ai une fonction MatchPlayed, qui retourne un booléen indiquant si oui ou nom le match a déjà été joué. De même, j'ai une fonction InSession.

Ca donne donc quelque chose comme ça :

C'est, en gros ce que fait mon code sauf que ça me donne pas le bon nombre de sessions. Par exemple la ça m'en donne 6.

Donc c'est même pire que ce que je pensais avec l'algo que j'ai donné mon soft me calcule les session suivantes :
AB - CD - EF
AC - BD
AD - BC
AE - BF
AF - BE
CE - DF
CF - DE

Pour l'optimisation du l'utilisation du temps on repassera... Mais je sais pas vraiment comment faire pour que çame donne le meilleur ordre de déroulement.
Si quelqu'un a une piste?

(UP Caché!)

J'ai écrit un petit programme qui génère la liste des rondes  d'un tournoi et j'avais fait une espèce de doc : http://darkoli.free.fr/programmation/tournoi.html.
Si mes souvenirs sont bon j'utilisais une fonction récursive.

Merci j'ai enfin un bon point de départ.
Domage qu'il n'y ait pas le code...

Je peux de donner un exemple minimaliste de la fonction récursive qui détermine la liste de toutes les sessions.

Le tableau tableau contient la session en cours de génération, sa taille correspond au nombre de participants (+1 si impair !).
Il ne te reste plus qu'a sélectionner les sessions qui sont compatibles entres-elles !
Pour cela j'utilise le tableau tours qui contient N fois le tableau tableau : N = nombre de rondes.
 
Il y a une variable globale (je sais, c'est pas bien) : GLOBAL_nb_joueurs (le nombre de participants (+1 si impair)).
 
Appel de la fonction :

Merci je vais étudier ça.
Et pourquoi utiliser une variable global? Pourquoi pas un paramètre de plus à ta fonction?

J'étais paresseux à l'époque.

En fait je viens de découvrir qu'il existe une méthode assez simple et vachement plus rapide !
Le système (de) Berger ou les tables de Berger.
Pour N joueurs : N pair !
Il faut initialiser un tableau de N/2 lignes et 2 colonnes de la façon suivante :

Pour la première session, le joueur 1 rencontre le joueur N, le joueur 2, le joueur N-1, ...
 
Pour la session suivante, il suffit de faire tourner les joueurs dans le sens inverse des aiguilles d'une montre sauf le joueur N qui ne bouge pas !
Exemple pour N = 6
Session 1

Session 2

Session 3

Ensuite pour que tous les joueurs changent de couleur (pour les échecs par exemple), il suffit d'inverser les deux joueurs de la première ligne sinon le joueur N joue toujours avec la même couleur.
 
Finalement, les tables que tu trouveras sur internet sont présentées de façon à ce que pour chaque session le joueur 1 rencontre le joueur S (numéro de la session), pour la première session il rencontre le joueur N.

Merveilleux, absolument merveilleux. Merci.
Je me disais bien qu'un type avait déjà dû trouver quelque chose sur ce problème. Ayant son nom, j'ai pu trouver pas mal de truc, après avoir passer les sites de vente de meubles : en effet "table de berger" ne donne pas vraiment ce que j'attendais, au départ.
Encore merci