Discussion :

[Finkelstein]

Bonjour a tous,

J'aurais peut être du poster ça dans le sous forum sur l'algo mais il se trouve que je développe en PHP ...

Je suis responsable d'une ligue sportive (enfin quand je dis sportive ça reste du Bloodbowl ...) et je dois gérer les matchs (qui affronte qui).
Je me suis donc dit que je pourrais gérer ça informatiquement.

Voici les contraintes (règles de gestion) de cette ligue.
- la ligue est découpée en saison, une saison se déroule, en gros, sur une année
- chaque saison peut comporter un nombre différent de joueur (en fonction des inscriptions)
- chaque saison est découpée en X journées où chaque joueur va jouer un match
- a la fin de ces X journées se déroulent les phases finales (demi-finales et finales) en fonction du classement : seuls les 4 premiers joueurs sont concernés
- a chaque journée, chaque joueur doit affronté un nouveau joueur différent de ceux qu'il a affronté lors des journées précédentes
- si le nombre de joueur est trop important on peut decider de découper le groupe de joueurs en une ou plusieurs poules

Je voudrais faire une ou des fonctions avec en paramètres : la liste des joueurs, le nombre de match joués avant les phases finales (journées), le nombre de poules
Ces fonctions permettraient de me sortir la liste des matchs par journées en tenant compte des contraintes listées précédemment.

Bien entendu, je ne demande pas le code tout fait : j'ai bien conscience que c'est compliqué (du moins, pour moi ça l'est) mais quelques pistes de réflexions qui pourraient m'aider.

Merci de votre aide.

[insaneness]

Bonjour,
C'est un projet intéressant, as tu commencé à réfléchir à une structure de données (MCD) ?
En vrac comme ça voici les entités qui pourraient ressortir :
- Saison (dateDebut, dateFin)
- Joueur (nom, prenom...)
- Journée (date, saisonID)
- Match (Joueur1, Joueur2, ScoreJ1, ScoreJ2, JourneeID)

Les relations :
- Saison/ Joueur ( == inscriptions)
- Saison / Journee
- Journée / Match

Ensuite une fois ceci codé, tu pourras faire les fonctions qui vont générer les journées requises (en fonction du nombre de joueurs) ainsi que les match qui en découlent.
Éventuellement par la suite une interface pour remplir et consulter les résultats des matchs

Sinon tu peux chercher des solutions sur GitHub, il y a pas mal de choses de dispo (à tester) exemple : https://github.com/mnito/round-robin

C'est très grossier mais ça peut te donner des idées pour commencer.

[Finkelstein]

Oui j'ai déjà commencé a faire tout ça (en fait, ça fait un moment que j'y réfléchis et je viens de commencer le dev).
Pour plus de précisions sur le développement, je développe avec Symfony 3.4

Comme tu l'as indiqué j'ai bien les entités Saison, Joueur, Journée et Match
de même que les relations que tu as cité (ca me fait plaisir de voir que j'y ai plutôt bien réfléchi )

Ce qui me pose surtout probleme, c'est déterminer qui affronte qui en qui en tenant compte des matchs des journées precedentes : il y a des formules statistiques a mettre en place (les combinatoires, je crois) et je suis nul en statistiques

[insaneness]

Il y a peut être une solution plus simple à mettre en place.

Si on veut créer tous les matchs d'une saison d'un seul coup (pas de match retour) :

Code php :

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
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
 
<?php
$joueurs = [0 => 'Thomas', 1 => 'Romain', 2 => 'Pierre', 3 => 'Jean', 4 => 'Paul', 5 => 'Jacques'];
 
 
$journees = null;
$teamCount = count($joueurs);
    if($teamCount < 2) {
        return [];
    }
 
    if($teamCount % 2 === 1) {
        array_push($joueurs, 'PAS DE MATCH');
        $teamCount += 1;
    }
 
    $halfTeamCount = $teamCount / 2;
    if($journees === null) {
        $journees = $teamCount - 1;
    }
 
    $schedule = [];
    for($journee = 1; $journee <= $journees; $journee += 1) {
        foreach($joueurs as $key => $joueur) {
            if($key >= $halfTeamCount) {
                break;
            }
            $j1 = $joueur;
            $j2 = $joueurs[$key + $halfTeamCount];
            //Home-away swapping
            $matchup = $journee % 2 === 0 ? [$j1, $j2] : [$j2, $j1];
            $schedule[$journee][] = $matchup;
        }
        rotate($joueurs);
    }
 
 
echo "<pre>"; echo var_dump($schedule); echo "</pre>";
 
 
 
 
function rotate(array &$items)
{
    $itemCount = count($items);
    if($itemCount < 3) {
        return;
    }
    $lastIndex = $itemCount - 1;
 
    $factor = (int) ($itemCount % 2 === 0 ? $itemCount / 2 : ($itemCount / 2) + 1);
    $topRightIndex = $factor - 1;
    $topRightItem = $items[$topRightIndex];
    $bottomLeftIndex = $factor;
    $bottomLeftItem = $items[$bottomLeftIndex];
    for($i = $topRightIndex; $i > 0; $i -= 1) {
        $items[$i] = $items[$i - 1];
    }
    for($i = $bottomLeftIndex; $i < $lastIndex; $i += 1) {
        $items[$i] = $items[$i + 1];
    }
    $items[1] = $bottomLeftItem;
    $items[$lastIndex] = $topRightItem;
}

Ce code va te donner en résultat un tableau 3 dimension. -> $schedule
Au premier niveau seront tes journées, au second les matchs et au dernier les joueurs.
On obtient donc pour mon exemple de 6 joueurs :
- 5 journées de 3 matchs chacune

J'ai adapté un bout de code du github que je t'ai donné dans ma première réponse.
Tu peux maintenant remplacer cela tes objets

[Finkelstein]

Il y a peut être une solution plus simple à mettre en place.

Si on veut créer tous les matchs d'une saison d'un seul coup (pas de match retour) :

Code php :

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
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
 
<?php
$joueurs = [0 => 'Thomas', 1 => 'Romain', 2 => 'Pierre', 3 => 'Jean', 4 => 'Paul', 5 => 'Jacques'];
 
 
$journees = null;
$teamCount = count($joueurs);
    if($teamCount < 2) {
        return [];
    }
 
    if($teamCount % 2 === 1) {
        array_push($joueurs, 'PAS DE MATCH');
        $teamCount += 1;
    }
 
    $halfTeamCount = $teamCount / 2;
    if($journees === null) {
        $journees = $teamCount - 1;
    }
 
    $schedule = [];
    for($journee = 1; $journee <= $journees; $journee += 1) {
        foreach($joueurs as $key => $joueur) {
            if($key >= $halfTeamCount) {
                break;
            }
            $j1 = $joueur;
            $j2 = $joueurs[$key + $halfTeamCount];
            //Home-away swapping
            $matchup = $journee % 2 === 0 ? [$j1, $j2] : [$j2, $j1];
            $schedule[$journee][] = $matchup;
        }
        rotate($joueurs);
    }
 
 
echo "<pre>"; echo var_dump($schedule); echo "</pre>";
 
 
 
 
function rotate(array &$items)
{
    $itemCount = count($items);
    if($itemCount < 3) {
        return;
    }
    $lastIndex = $itemCount - 1;
 
    $factor = (int) ($itemCount % 2 === 0 ? $itemCount / 2 : ($itemCount / 2) + 1);
    $topRightIndex = $factor - 1;
    $topRightItem = $items[$topRightIndex];
    $bottomLeftIndex = $factor;
    $bottomLeftItem = $items[$bottomLeftIndex];
    for($i = $topRightIndex; $i > 0; $i -= 1) {
        $items[$i] = $items[$i - 1];
    }
    for($i = $bottomLeftIndex; $i < $lastIndex; $i += 1) {
        $items[$i] = $items[$i + 1];
    }
    $items[1] = $bottomLeftItem;
    $items[$lastIndex] = $topRightItem;
}

Ce code va te donner en résultat un tableau 3 dimension. -> $schedule
Au premier niveau seront tes journées, au second les matchs et au dernier les joueurs.
On obtient donc pour mon exemple de 6 joueurs :
- 5 journées de 3 matchs chacune

J'ai adapté un bout de code du github que je t'ai donné dans ma première réponse.
Tu peux maintenant remplacer cela tes objets

Merci pour cet exemple, je vais voir ce que ca donne et m'en inspirer

[Invité]

Bonjour,

...je viens de commencer le dev...
...Ce qui me pose surtout probleme, c'est déterminer qui affronte qui en qui...

Si je peux me permettre...
AVANT de "commencer le dev", il faut surtout ÉCRIRE SUR LE PAPIER toute la procédure (cahier des charges) :

• Qui fait quoi ?
• Quand ?
• Comment ?
• A quel moment ? (enchainement des actions)
• De quoi on a besoin ?
• à quoi on doit aboutir ?
• ... ?

C'est justement SUR LE PAPIER que tu devras lever le voile sur tes "problématiques".
Et ce, AVANT de programmer, car ça pourrait modifier ta CONCEPTION initiale (tables / tables relationnelles en BDD,...).

Une BONNE CONCEPTION, dès le départ, évite de nombreuses heures de galères et la perte prématurée de cheveux (blancs)...

...il y a des formules statistiques a mettre en place...

Pour cette partie, le papier et le crayon sont obligatoires (en plus des connaissances dans le domaine).

"Programmer", c'est bien. Savoir "Quoi et comment", c'est mieux.

[Finkelstein]

@jreaux92
C'est marrant, on dirait que tu me connais : j'ai souvent l'habitude de partir comme une fusée dans les dev mais cette fois fait exception, j'ai bien réfléchi a ce que je voulais et comment j'allais le faire. Je bute juste sur la facon d'obtenir des matchs uniques sur toutes la durée de la saison (phase finale exclue, evidemment)
C'est vrai que je ne l'ai pas précisé mais si on lit entre les lignes de ma réponse a insaneness, ont voit que j'ai déjà fait la "conception sur papier" dont tu parles.
J'ai les entités et leur liens entre elles, je sais ce que je veux faire de cette appli et dans quel sens je pense procéder.

Si tu veux je peux même répondre a ton questionnaire :
Qui fait quoi ? Les matchs sont joués par des joueurs, Les matchs sont joués durant des journées, Les joueurs s'inscrivent a une saison, La saison est découpée en journées
Quand ? En début de saison. Je voudrais, a l'initialisation de la saison, etre capable de dire a mes joueurs : La saison va durer X journees et pour chacune de ces journees vous allez affronter tel autre joueur
Comment ? C'est justement la réponse ou au moins une ébauche que je viens chercher ici
A quel moment ? (enchainement des actions) D'abord creer les journees puis les matchs, les entités de joueurs et saisons existent deja
De quoi on a besoin ? Je pense que les entités Match, Joueurs, Journee et Saison devraient suffir
à quoi on doit aboutir ? En début de saison, un tableau explicatif de qui affrontera qui lors de chacune des journées de la saison
... ?

Mon vrai soucis, c'est que j'ai beau tourner le problème dans tous les sens : je n'arrive pas a trouver de formule/algo assez générique me permettant de créer X match par journée pendant Y journées de facon a ce que chaque match soit unique durant toutes les Y journées.

C'est pourquoi je viens ici demander de l'aide ici

[Invité]

@jreaux92
C'est marrant, on dirait que tu me connais...

1- C'est jreaux62 (en rapport à mon département )

2- Oui, je te "connais"... à force de répondre, depuis 2008, à ceux qui posent des questions sur DVP...
Et aussi, et surtout, parce que je me mets "à ta place".
C'est le propre du "pédagogue".

Certes, je ne prétends pas connaitre la réponse, mais je pense pouvoir t'y amener.
Par la TA réflexion.
Je n'ai pas d'autre prétention.