Teaching

TME 72012 LI 230

Modélisation d'une liste (file ou pile)

Une liste est une structure récursive qui permet de stocker un nombre dynamique d'objets (au contraire des tableaux statiques). Les opérations usuelles des listes sont les suivantes :

  • ajouter un élément (méthode void push(Object o))
  • enlever un élément (méthode Object pop())
  • tester si la liste est vide (méthode boolean isEmpty())
  • fusionner 2 listes (méthode void merge(List l))
  • copier une liste (méthode List copy())

Chaque élément d'une liste est défini récursivement par les variables :

  • Object obj : l'objet stocké dans cet élément
  • Element prec : l'élément prédécésseur dans la liste (et null si l'élément est premier de la liste)
  • Element next l'élément succésseur (et null si l'élément est le dernier de la liste).

On distingue en particulier deux types de liste :

  • une pile : le premier élément enlevé est le dernier élément ajouté (last in first out, LIFO)
  • une file : le premier élément enlevé est le premier élément ajouté (first in first out, FIFO)

Coder les classes List, Pile, File, Element pour représenter les listes,files et piles d'objets génériques java (Object). Quelles relations hierarchiques ? Quelle(s) classe(s)/méthode(s) sont abstraites ? N'oubliez pas de coder les accesseurs des variables et les constructeurs adéquats.

Les robots pollueurs

Le monde est consttitué d'une matrice de cases. Différents types de robots agissent dans ce monde : des robots pollueurs et des robots nettoyeurs. Les robots pollueurs se baladent dans le monde et déposent des papiers gras sur les cases où ils se trouvent. Les robots nettoyeurs quant à eux ne supportent pas la vue d'un papier gras et l'enlèvent dès qu'ils en voient un sur une case. Ils ne peuvent par contre pas en transporter plus d'un volume donnée et ils s'en débarassent uniquement lorsqu'ils sont sur un bord du tableau.

Les robots pollueurs sont de deux sortes :

  • les robots idiots : à chaque tour ils décident au hasard ou ils se déplacent et avec une probabilité de 20% déposent un papier gras sur la case.
  • les robots butés : ils se déplacent uniquement sur une ligne, choisie aléatoirement au début et d'une case à la fois. Ils déposent un papier gras sur la case avec une probabilité de 30%.

Les robots nettoyeurs parcourent le monde en se déplaçant de deux façons :

  • les normaux : à chaque fin de ligne, le robot se déplace à la ligne suivante et la parcours en sens inverse;
  • les maniaques : vers la case sale la plus proche.

Plusieurs papiers peuvent exister sur une case, on utilisera une liste (pile ou file à votre avis ?) pour les représenter.

Les constructeurs, accesseurs, modifieurs et les méthodes toString() seront créés dans chaque classe suivant les besoins. Le monde sera représenté par une chaîne de caractère où une case avec papier gras sera représentée par un entier (le nombre de papiers), une case vide par . et une case avec un robot par une lettre decrivant le robot.

  1. Dessiner l'hierarchie des classes correspondant à la description précédente.
  2. Ecrire la classe Case avec les variables et méthodes suivantes :
    • variable i et j avec la position de la case;
    • une liste listePapier qui permet de stocker les papiers gras de la case
    • une méthode metPapierGras() qui ajoute un papier gras
    • une méthode prendPapierGras() qui enlève un papier gras à la case.
    • une méthode estSale() qui indique si la case est sale
  3. Ecrire la classe Monde avec les variables et méthodes suivantes :
    • le nombre de lignes nbL, de colonnes nbC, et un tableau de cases de la classe Case (ci-dessous);
    • un constructeur sans paramètres (par défaut taille 10x10) et un avec;
    • une méthode metPapierGras(int i, int j) qui ajoute un papier gras à la case i,j
    • une méthode prendPapierGras(int i, int j) qui enlève un papier gras à la case i,j
    • une méthode estSale(int i, int j) qui indique si une case est sale
    • une méthode nbPapiersGras() qui rend le nombre de papier gras dans le monde (3 solutions possibles !).
  4. Ecrire dans une calsse TestRobot la méthode main et y créer un monde de 10 lignes et 10 colonnes. Y tester les méthodes metPapierGras,prendPapierGras et estSale. Dans la suite on n'oubliera pas de reporter la hiérarchie construite en question 1 dans la définition des différentes classes (mot clé extends). Chaque fois qu'on écrira une variable ou une méthode, on en enrichira le dessin de la hiérarchie des classes.
  5. La classe Robot est munie d'une méthode nextRound() qui sera appellée à chaque pas de temps. Cette méthode exécute dans l'ordre la méthode move() qui fait bouger d'une case le robot selon sa nature et la méthode polluer() ou nettoyer() selon que le robot est pollueur ou nettoyeur. Ecrire la classe Robot et qui contient les variables et méthodes (static ? abstract ?) suivantes :
    • posx, posxy : la position du robot
    • m : variable de type Monde : pourquoi a-t-on besoin de référencer le monde du robot ?
    • deux constructeurs, un avec en paramètres la position et le monde, l'autre avec le monde et qui initialise le robot à une position aléatoire.
    • les méthodes nextRound() et move() (pourquoi pas polluer et nettoyer ?)
  6. Ecrire la classe RobotPollueur (ne pas oublier une variable proba pour la probabilité de polluer), la classe RobotIdiot et RobotBute et les méthodes abstraites correspondantes.
  7. Ecrire la classe RobotNettoyeur et RobotNormal (ne pas oublier une variable pour indiquer le volume de papiers gras pouvant être transporté). Attention, dans la méthode move, il faudra penser à aller vider les papiers si le robot est plein.
  8. Ajouter dans un monde une méthode ajouterRobot(Robot r) et une variable listeRobot qui contiendra la liste des robots. Modifier le constructeur de robot pour ajouter automatiquement un robot quand il est créé. Ajouter une méthode nextRound() qui appellera successivement toutes les méthodes nextRound des robots. Tester vos classes.
  9. (Option) Coder le robot RobotManiac.

Home

Research?

Teaching

(2014-2015)

Licence

Master

edit SideBar

Blix theme adapted by David Gilbert, powered by PmWiki