Algorithmique et programmation avec Java (NFA002)

Algorithmique et programmation avec Java (NFA002)
Deuxième session – 13 septembre 2012
Aucun document n’est autorisé. Le barème est donné à titre indicatif.
Exercice 1 : listes (4 points)
Etudiez le programme suivant, qui utilise les deux classes ListeIter et ElementListe vues en cours et
données en annexe du présent sujet.
public class Test {
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g u m e n t s ) {
L i s t e I t e r l a l i s = new L i s t e I t e r ( ) ;
l a l i s . ajouterAuDebut ( 1 2 ) ;
l a l i s . ajouterAuDebut ( 8 ) ;
l a l i s . ajouterAuDebut ( 5 ) ;
l a l i s . ajouterAuDebut ( 1 0 ) ;
ElementListe e l t = l a l i s . getPremier ( ) ;
elt = elt . getSuivant ( ) ;
elt = elt . getSuivant ( ) ;
Terminal . e c r i r e I n t l n ( e l t . getValeur ( ) ) ;
Terminal . e c r i r e I n t l n ( e l t . getSuivant ( ) . getValeur ( ) ) ;
}
}
1. faites un schéma représentant les valeurs des variables lalis et elt à la fin de l’exécution de la
méthode main. Ce schéma représentera les objets par des rectangles et les références par des flèches.
2. qu’affiche ce programme lors de son exécution ? Aucune justification n’est demandée.
Exercice 2 : objets et références (3 points)
Etudiez le programme suivant.
c l a s s Compteur {
private int x ;
Compteur ( i n t n ) {
x=n ;
}
void i n c r ( ) {
x ++;
}
i n t getX ( ) {
return x ;
}
}
p u b l i c c l a s s Truc {
1
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
Compteur c1 , c2 ;
Compteur [ ] t a b = new Compteur [ 3 ] ;
c1 = new Compteur ( 5 ) ;
f o r ( i n t i = 0 ; i <3; i ++){
t a b [ i ] = new Compteur ( i ∗ 1 0 ) ;
}
c2 = t a b [ 0 ] ;
tab [2] = tab [ 0 ] ;
c1 . i n c r ( ) ;
c2 . i n c r ( ) ;
f o r ( i n t i = 0 ; i <3; i ++){
tab [ i ] . incr ( ) ;
}
T e r m i n a l . e c r i r e I n t l n ( c1 . getX ( ) ) ;
T e r m i n a l . e c r i r e I n t l n ( c2 . getX ( ) ) ;
f o r ( i n t i = 0 ; i <3; i ++){
T e r m i n a l . e c r i r e I n t l n ( t a b [ i ] . getX ( ) ) ;
}
}
}
1. combien d’objets de type Compteur sont créés dans ce programme ? (justifiez en quelques lignes).
2. qu’affiche ce programme ? (aucune justification demandée)
3. combien d’objets de type Compteur sont accessibles à la fin du programme ? Rappel : un objet est
accessible s’il existe une expression java pour le désigner.
Exercice 3 : récursivité (3 points)
On définit une fonction f au moyen de la définition par cas suivante :
– f (x, 0) = 1
– f (x, y) = y ∗ f (x, y − 1) si y > 0
– f (x, y) n’est pas définie si y < 0
Cette définition est une définition récursive parce que le deuxième cas utilise f à gauche et à droite de
l’égalité.
1. écrivez une méthode en java implémentant la fonction f de façon récursive.
2. que calcule cette fonction ? (réponse en une ou deux phrases)
Exercice 4 : structures de données (5 points)
On veut représenter un jeu de dames. Ce jeu se joue sur un damier qui est un plateau de 10 colonnes et
10 lignes (100 cases). Les cases sont alternativement blanches et noires. Les pièces sont posées sur des cases
noires. Il y a deux types de pièces : les pions et les dames, et deux couleurs de pièces : noire et blanche.
Chaque joueur a les pièces d’une couleur.
2
F IGURE 1 – damier vide et damier en cours de partie
Question 1 : les pièces
On veut utiliser l’héritage pour définir un type Java comprenant les objets pions et les objets dames.
Pour cela, il faut définir deux ou trois classes avec une d’entre elles qui est la classe mère ou superclasse de
l’autre ou des deux autres.
Les pions et les dames ont en commun d’avoir une couleur (blanche ou noire), d’être sur une case noire
et de se déplacer en diagonale. Mais les pions ne peuvent se déplacer que d’une case et dans deux directions
alors que les dames peuvent se déplacer de plusieurs cases dans quatre directions.
Donnez le squelette des deux ou trois classes à écrire avec leurs variables d’instance, leurs constructeurs,
une méthode qui détermine si un déplacement est possible et une méthode qui réalise un déplacement. Pour
écrire cela, vous supposerez que les cases du damier sont identifiées par deux coordonnées x et y de type int.
Vous ne donnerez pas le code des méthodes, mais pour chaque méthode vous donnerez son nom, le type des
paramètres et du résultat et si la méthode lève une exception. Vous ferez attention aux variables et méthodes
qui sont héritées et à celle qui doivent être ajoutées ou redéfinies dans les sous-classes.
Question 2 : damier et tableaux
On veut représenter le damier par un tableau ou plusieurs tableaux à deux dimensions, les indices des
deux dimensions donnant les coordonnées des cases.
Laquelle des trois propositions suivantes est vraie :
1. grâce à l’héritage, on peut utiliser le type de la super-classe ou classe mère comme type pour les cases
du tableau et cela permet de mettre à la fois des pions et des dames.
2. grâce à l’héritage, on peut utiliser le type de la sous-classe ou classe fille comme type pour les cases
du tableau et cela permet de mettre à la fois des pions et des dames.
3. on ne peut de toute façon pas mettre des pions et des dames dans le même tableau. Il faut deux tableaux
différents, un pour les pions l’autre pour les dames.
3
Question 3 : cases vides
Dans le tableau, comment va-t-on représenter les cases vides ?
Question 4 : cases blanches
On veut à présent une représentation qui distingue les cases noires qui peuvent être vide ou contenir une
pièce et les cases blanches qui sont nécessairement vides. Comment peut-on faire ? Donnez les déclarations
de variables et le code java qui représentent un damier vide (sans pièce dessus). Indice : on peut représenter
chaque case du tableau par un objet.
Exercice 5 : courses de chevaux (5 points)
On veut réaliser un petit jeu où trois chevaux font une course sur un tapis de jeu comportant 80 cases.
Le premier à franchir la ligne d’arrivée a gagné. A chaque tour, la distance parcourue par chaque cheval est
déterminée par un lancer de dé (valeur entre 1 et 6). Il y a un cheval rouge, un cheval bleu et un cheval jaune.
Le programme dispose d’un affichage en mode texte où les chevaux sont représentés par la première lettre de
leur couleur (r pour rouge, b pour bleu, j pour jaune) les cases vides par un espace et la ligne d’arrivée par un
point d’exclamation. Entre chaque tour, le programme affiche la position courante et attend que l’utilisateur
tape sur la touche entree. Ecrivez un programme Java respectant ces spécifications.
Pour attendre la frappe de la touche entree, vous pouvez utiliser l’instruction Terminal.lireString. Pour
le lancer de dé, vous pouvez utiliser la méthode suivante :
s t a t i c int lancerDe (){
r e t u r n ( i n t ) ( Math . random ( ) ∗ 6 + 1 ) ;
}
A chaque appel, cette méthode renvoie un nombre entier compris entre 1 et 6.
Annexe : les classes ElementListe et ListeIter
public class ElementListe {
private int valeur ;
private ElementListe suivant ;
public ElementListe ( int valeur , ElementListe suivant ) {
this . valeur = valeur ;
this . suivant = suivant ;
}
public ElementListe ( int v ) {
this . valeur = v ;
this . suivant = null ;
}
public int getValeur ( ) {
return v a l e u r ;
}
public void s e t V a l e u r ( i n t v a l e u r ) {
this . valeur = valeur ;
}
4
public ElementListe getSuivant ( ) {
return s u i v a n t ;
}
public void s e t S u i v a n t ( ElementListe s u i v a n t ) {
this . suivant = suivant ;
}
}
public class L i s t e I t e r {
ElementListe premier ;
public ElementListe getPremier ( ) {
return premier ;
}
public void ajouterAuDebut ( i n t v ) {
ElementListe ancienPremier= premier ;
p r e m i e r = new E l e m e n t L i s t e ( v , a n c i e n P r e m i e r ) ;
}
...
}
5