Nous voulons modéliser des tournois de sport.
Une équipe sera représenté seulement par son nom et pour simplifier, même dans les structures, nous utiliserons des char *
.
Valable pour l’ensemble des questions, au lieu de toutes fonctions “qui retournent” vous pouvez lire : qui modifient via un pointeur passé en paramètre.
Un match sera représentée par une structure (game
) contenant un tableau de
deux équipes (teams
), un tableau de deux entiers (scores
) et un statut
(status
). Le statut indiquera : si le match n’a pas été joué, si il y’a eu
égalité ou sinon qu’elle équipe a gagnée. Définir tout ce qui est
nécessaire pour cela (structure et constantes).
Écrire la fonction make_game
prenant deux noms d’équipe en paramètre et
qui retourne un match non disputé entre ces équipes.
Écrire la fonction winner
qui, en fonction d’un match, retourne le nom de
l’équipe gagnante s’il y’a un gagnant ou NULL
sinon.
Écrire la fonction print_game
qui affiche les participants d’un match
sous la forme equipe1 - equipe2
. Écrire la fonction print_result
qui
affiche le résultat d’un match sous la forme score1 - score2
et si le
match a été disputé le score du gagnant est précédé d’une *
.
Faire la fonction print_games
qui, étant donné un tableau de matchs (et sa
taille) affiche sur une même ligne, séparés par une tabulation, les matchs
(cf. print_game
). Attention nous ne voulons pas de tabulations inutiles.
Écrire la fonction int make_tournament(int players, char *teams[], struct
game games[])
qui remplit un tableau de matchs où le meilleur rencontre les
plus mauvais, le second rencontre l’avant-dernier, etc. On suppose que le
nombre de joueurs est pair, que teams
est trié et que le tableau games
à
au moins players/2
cases. Cette fonction retourne le nombre de matchs
ainsi construit.
Quelle est la condition a vérifier pour qu’un tournoi soit complet ? Écrire
la fonction qui, étant donné un nombre de candidats n
, retourne le plus
grand nombre inférieur à n
tel que le tournoi soit valide.
Écrire la fonction int make_pool(int players, char *teams[], struct game
games[])
qui remplit un tableau matchs en faisant jouer tous les joueurs
contre tous les autres, avec des matchs aller et retour (i.e., (i, j) et (j,
i)). Cette fonction retourne le nombre de matchs ainsi construit.
On supposera que la fonction void random_results(int count, int scores[])
existe et qu’elle remplit un tableau de scores
de taille count
. On veut
écrire la fonction play_game
qui simule un match. Pour cela la fonction
remplit un tableau de score (int) passé en paramètre et retourne une valeur
compatible avec le statut d’un match. De plus, nous imposons maintenant la
règle suivante : en cas de match nul, on rejoue une manche de plus (appel à
random_results()
), le score final est la somme de toutes les manches.
void random_results(int count, int scores[])
{
while (--count)
scores[count] = rand()%5;
}
Faire la fonction qui retourne une match qui verra s’affronter les deux vainqueurs des deux matchs passés en paramètre.
Écrire la fonction play_games
qui étant donné un tableau de matchs (et sa
taille), joue tous les matchs non joués. C’est-à-dire : à la fin, tous les
matchs contenus dans le tableau auront un score et un statut à jour.
Faites la fonction prepare_next_round
qui, étant donné un tableau de
matchs et sa taille, apparie les vainqueurs des matchs deux à deux (le
premier avec le second, etc).
On veut maintenant lier les matchs les uns avec les autres, pour cela on se
propose d’amender la structure game
en rajoutant les deux champs
suivants: struct game* previous_games[2]; struct game *next_game;
.
Modifier ou refaîtes votre fonction next_game
pour qu’elle tienne compte
de ces nouveaux champs.
Écrire la fonction void rank_teams(int count, char *teams[], int points[],
int goals[])
qui classe les équipes en fonction de leur nombre de points
respectifs et, en cas d’égalité, du nombre de buts marqués. Remarque: on
suppose que ces conditions sont suffisantes pour lever les égalités.
Rappel de syntaxe : struct point p ; /*...*/ p.x = p.y + 10;
↩