1   Description

Lors de cette dernière mission, vous allez implémenter un classement de résultats de coureurs, chaque résultat représenté par un coureur (ayant un certain nom et âge) et le temps effectué par ce coureur. Ces résultats doivent être ordonnés selon leur temps dans une liste chaînée ordonnée. Le meilleur résultat (le coureur avec le meilleur temps) se trouve en tête de la liste. Le résultat du coureur le plus lent se trouve en queue de la liste.

Pour compléter cette mission vous trouverez sur INGInious déjà une grande partie du code nécessaire, sauf l'implémentation complète de la classe Classement que vous devez produire, ainsi que la classe OrderedLinkedList qu'elle doit utiliser. Vous devez également écrire des classes de test détaillées (ClassementTest et OrderedLinkedListTest) en utilisant le framework de test unittest, pour vérifier votre implémentation de la classe Classement.

Vous aurez accès à une implémentation assez complète d'une classe LinkedList sur laquelle vous pouvez vous baser, ou que pouvez étendre, pour implémenter la classe OrderedLinkedList. L'archive qu'on vous fournira contient également une implémentation primitive de la classe Classement à base d'un dictionnaire. Néanmoins, cette implémentation est encore incomplète (elle ne gère pas correctement la position des coureurs dans le classement). Vous devez la remplacer par votre implémentation. Elle permet toutefois au programme de fonctionner. Il suffit d'exécuter la méthode de classe main() de la classe Main dans le fichier main.py: le programme simulera à la console l'ajout d'un nouveau résultat aléatoire toute seconde.

2   Etapes

1. Avant de commencer lisez bien le code qui vous a été fourni afin que vous comprenez bien sa structure et son comportement.

2. Vous allez utiliser une liste chaînée ordonnée (OrderedLinkedList ) pour implémenter un tel classement de coureurs. Réfléchissez aux différentes opérations qu'on peut effectuer sur un classement et comment on devrait les implémenter en utilisant une liste chaînée ordonnée.

3. Avant de commencez à implémenter cette classe Classement, représentez la structure de votre classement comme liste chaînée ordonnée graphiquement, et montrez ce qu'il se passe lorsque, successivement:

   • Vous créez un classement vide;
   • Vous ajoutez un résultat pour le coureur A en tête de classement (méthode add);
   • Vous ajoutez un résultat pour le coureur B en fin de classement (méthode add);
   • Vous ajoutez un résultat pour le coureur C en milieu de classement (méthode add);
   • Vous recherchez les résultats des coureurs A, B et C (méthode get);
   • Vous recherchez les positions des coureurs A, B et C (méthode getPosition);
   • Vous retirez le résultat du coureur B (méthode remove);
   • Vous retirez le résultat du coureur A (méthode remove);
   • Vous tentez de retirer le résultat d'un coureur D (méthode remove).

4. Implémentez la classe OrderedLinkedList dont vous aurez besoin pour implémenter votre classe Classement.

5. Implémentez une classe de test OrderedLinkedListTest pour tester le bon fonctionnement de votre classe OrderedLinkedList.

6. Sur base de notre implémentation incomplète de la classe Classement au moyen d'une dictionnaire, écrivez un squelette de votre classe Classement au moyen d'une liste chaînée ordonnée, qui remplacera la notre. Respectez bien les pré- et post-conditions des différentes méthodes de la classe :

   class Classement :
   
       def __init__(self):
           """
           @pre: -
           @post: un classement vide de taille 0 a été créé
           """
   
       def size(self):
           """
           Méthode accesseur.
           Retourne la taille de ce classement.
           @pre:  -
           @post: Le nombre de résultats actuellement stockés dans ce classement a été retourné.
           """
   
       def add(self,r):
           """
           Ajoute un résultat r dans ce classement.
           @pre:  r est une instance de la classe Resultat
           @post: Le résultat r a été inséré selon l'ordre du classement.
                  En cas d'ex-aequo, r est inséré après les autres résultats de même ordre.
           """
   
       def get(self,c):
           """
           Retourne le résultat d'un coureur donné.
           @pre c est un Coureur
           @post retourne le premier (meilleur) Resultat r du coureur c dans le
                 classement. Retourne None si le coureur ne figure pas (encore)
                 dans le classement.
           """
   
       def get_position(self,c):
           """
           Retourne la meilleure position d'un coureur dans ce classement.
           @pre c est un Coureur
           @post retourne un entier représentant la position du coureur c dans ce classement,
                 à partir de 1 pour la tête de ce classement. Si le coureur figure plusieurs fois
                 dans le classement, la première (meilleure) position est retournée.
                 Retourne -1 si le coureur ne figure pas dans le classement.
           """
   
       def remove(self,c):
           """
           Retire un résultat du classement.
           @pre  c est un Coureur
           @post retire le premier (meilleur) résultat pour le coureur c du classement.
                 c est comparé au sens de __eq__. Retourne c si un résultat a été retiré,
                 of False si c n'est pas trouvé dans la liste.
           """
   
       def __str__(self):
           """
           Méthode magique
           Retourne une représentation string de cet objet.
           @pre:  -
           @post: Retourne une représentation de ce classement sous forme d'un string,
                  avec une ligne par résultat.
           """
   

7. Ecrivez une classe de test ClassementTest, la plus complète possible permettant de vérifier le bon fonctionnement de votre implémentation de la classe Classement. Utilisez pour cela les méthodes comme assertEqual ou d'autres méthodes définies dans unittest.

8. Pensez à découper votre classe de test en plusieurs méthodes. Cela facilitera la visualisation des résultats des tests. Vous trouverez sur la tâche INGInious un exemple de classe de test CoureurTest pour la classe Coureur.

9. Justifiez vos tests dans le fichier README.TXT.

10. Remplacer votre classe Classement par celle qui vous est fourni et exécutez la méthode main() de la classe Main. Observez que vos classements sont correctement mis à jour. Félicitations!

11. N'oubliez pas de soumettre votre implémentation des classes OrderedLinkedList et Classement, vos classes de test OrderedLinkedListTest et ClassementTest et votre fichier README.TXT à votre tuteur.

3   Diagramme de classes

Le diagramme de classes suivant résume les différentes classes et attributs qui feront partie de votre solution finale :

4   Remise de votre solution

Pour cette mission, vous devez soumettre au serveur de soumissions de programmes du cours, vos classes OrderedLinkedList et Classement dans des fichier orderedlinkedlist.py et classement.py, vos classes test OrderedLinkedListTest et ClassementTest dans des fichiers orderedlinkedlisttest.py et classementtest.py, ainsi que votre fichier README.txt.