Université Paris 6 Licence d'informatique	Module de Programmation Année 1999-2000

Travaux dirigés n° 3

Exercice 1

Évaluez les expressions ci-dessous. On supposera qu'à chaque question correspond une nouvelle session camllight interactive.

1.

let f g h x = g(h(x+1)*10)+3;;
let t = f (function x -> x + 2);;
let u = t (function x -> x * 5);;
let v = u 5;;

let v = make_vect 3 5;;
let m = make_vect 2 v;;
m.(1).(2) <- 0; m;;
let w = [| 1; 2; 3 |];;
m.(1) <- w; m;;
m.(1).(2) <- 9; m;;

let f v = let nb = ref 0 in
   for i = 0 to vect_length v - 1 do
      nb := !nb + v.(i);
      v.(i) <- !nb
   done;;
let v = make_vect 4 5;;
f v; v;;

exception pas_grave of int;;
exception grave of string;;
let pseudo_id x =
   if (x < 0) then raise (pas_grave (-x))
   else if (x = 0) then raise (grave "Argh !!!") else x ;;
pseudo_id(-4);;
pseudo_id(0);;
pseudo_id(2);;
let f = let val = 10 in function x ->
   try let val = 100 in pseudo_id(x) - val with
      | pas_grave n -> if (n < 0) then raise(grave "impossible ?") else n + val
      | grave "Argh !!!" -> raise(pas_grave(10))
      | grave s -> raise(grave "possible ?");;
f(-100);;
f(0);;
f(100);;
f(grave "Ouf !!!");;
f(raise(grave "Ouf !!!"));;

Exercice 2

Dans cet exercice, vous allez progressivement programmer une version relativement simple (pas de graphisme ni de gestion du temps) du jeu de démineur. Celui-ci se présente sous la forme d'un plateau rectangulaire de nb_lignes × nb_colonnes cellules. Au début du jeu, des mines (au nombre de nb_mines) sont déposées dans des cellules au hasard, mais le contenu des cellules est caché au joueur. À chaque tour de jeu, ce dernier sélectionne une nouvelle cellule et effectue l'une des opérations suivantes :

il marque la cellule comme ayant, d'après lui, une mine. Il peut réaliser cette opération nb_mines fois ;
il découvre le contenu de la cellule.

Le but est de découvrir l'ensemble des cellules ne contenant pas de mine. Si le joueur découvre une case minée, il saute avec et le jeu est perdu, sinon, on lui indique le nombre de mines autour de cette cellule, c'est-à-dire sur les 8 cellules adjacentes si la cellule n'est pas au bord du plateau, les 5 cellules adjacentes si elle est sur un bord mais pas dans un coin, et les 3 cellules adjacentes si elle est dans un coin. Pour réaliser le jeu, vous utiliserez les types et structures de données suivantes :

type Statut_Cellule = Minée | Non_minée of int ;;
C'est le statut d'une cellule : soit elle est minée, soit elle ne l'est pas et, dans ce cas, on indique le nombre de mines sur les cases adjacentes.
type Marquage_Cellule = Découverte | Marquée_Minée | Non_découverte ;;
C'est le marquage d'une cellule : soit elle a été decouverte par le joueur, soit elle a été marquée comme contenant une mine, soit elle n'a pas encore été sélectionnée par le joueur.
champ_mines : (Statut_Cellule, Marquage_Cellule) vect vect
Le champ de mines est une matrice de nb_lignes × nb_colonnes cellules. Pour chaque cellule, on stocke les informations sur son statut et sur son marquage.
exception En_dehors_du_champ_de_mines ;;
exception Perdu ;;

1. En se fondant sur les informations ci-dessus, écrivez une fonction ajoute_mine qui prend en argument un champ de mines et deux coordonnées x et y. Cette fonction rajoute une mine dans le champ sur la y^ème ligne, x^ème colonne du champ. Elle met bien évidemment à jour, pour chaque cellule non minée du champ de mines, le nombre de cellules minées qui lui sont adjacentes. Enfin, elle retourne un élément de type unit. Par contre, si les coordonnées x,y sont en dehors des coordonnées valides du champ de mines, la fonction lève une exception En_dehors_du_champ_de_mines.
2. En utilisant la fonction de la question précédente, écrivez une fonction initialise_mines qui prend en argument nb_mines ainsi qu'une matrice d'éléments de type (Statut_Cellule, Marquage_Cellule), qui initialise cette matrice pour le début d'une partie, et qui renvoie finalement un élément de type unit.
3. Écrivez une fonction marque, qui prend en argument un champ de mines, les coordonnées x,y d'une cellule de ce champ ainsi que le nombre de marquages déjà réalisés et nb_mines. Cette fonction vérifie si la cellule en question n'est pas déjà marquée. Le cas échéant, elle « démarque » la cellule, c'est-à-dire qu'elle lui donne le statut de Non_découverte, sinon, lorsque le nombre de marquages est inférieur au nombre de mines, elle marque la cellule. Enfin, elle renvoie le nombre de marquages présents dans le champ de mines à la fin de l'opération. Si les coordonnées x,y sont en dehors des coordonnées valides du champ de mines, la fonction doit lever une exception En_dehors_du_champ_de_mines.

4. Écrivez une fonction découvre, qui prend en argument un champ de mines, les coordonnées x,y d'une cellule de ce champ, ainsi que le nombre de cellules déjà découvertes. Cette fonction découvre la cellule située aux coordonnées x,y du champ de mines si celle-ci ne l'est pas déjà et renvoie le nouveau nombre de cellules découvertes. Si les coordonnées x,y sont en dehors des coordonnées valides du champ de mines, la fonction doit lever une exception En_dehors_du_champ_de_mines.

5. Modifiez la fonction de la question précédente de manière à ce que, lorsque la cellule aux coordonnées x,y a pour statut Non_minée 0, la fonction découvre toutes ses cellules adjacentes, et recommence récursivement avec toutes celles qui ont aussi pour statut Non_minée 0.
6. Écrivez une fonction affiche_mines qui prend en argument un champ de mines et qui affiche ce dernier. Les pourtours des cellules seront symbolisés de la manière suivante :

+-+

|x|

+-+

x est un caractère qui prendra les valeurs suivantes :

x = ` ` lorsque la cellule n'est pas découverte ;
x = `M` lorsque la cellule est marquée comme minée ;
x = `n`, où n Î {0,1,2,...,8}, lorsque la cellule est découverte. n est alors un chiffre égal au nombre de mines sur les cellules adjacentes.

7. À chaque tour, le joueur rentre l'action qu'il désire effectuer en rentrant une chaîne de caractères de la forme "x y a", où x et y sont des nombres correspondant aux coordonnées x,y d'une cellule du champ de mines, et où a est le caractère `M` lorsque le joueur veut marquer la cellule, ou `D` lorsqu'il veut découvrir la cellule. Écrivez une fonction action_joueur qui prend en argument la chaîne de caractères et qui renvoie le triplet (x,y,a) de type int * int * char.
8. Utilisez la fonction précédente pour écrire la fonction tour_de_jeu. Celle-ci prend en paramètres le champ de mines, les nombres de marquages et de découvertes déjà effectués ainsi que le nombre de mines dans le champ. La fonction attend alors que le joueur entre une phrase de la forme "x y a" au clavier (vous utiliserez pour cela la fonction read_line du module io), elle exécute alors l'action correspondante et elle affiche le champ de mines. Elle renvoie enfin un couple constitué du nombre de marquages et du nombre de découvertes effectuées depuis le début du jeu.

9. Écrivez enfin une fonction démineur qui prend un élément de type unit en argument et qui renvoie un unit. La fonction demande au joueur de rentrer la taille de la matrice et le nombre de mines du champ (vous pourrez pour cela utiliser la fonction read_int du module io). Elle crée alors le champ de mines et itère les tours de jeu jusqu'à ce que le joueur ait perdu ou qu'il ait fini la partie.

Ce document a été traduit de L^AT_EX par H^EV^EA.