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

Travaux dirigés n° 2

Exercice 1

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

let l = 3::[];;
[]@l@[4];;
l::[1];;
l@["34"; "2"];;

let xxx = (3,"45",true) and yyy = (1.2, "xxx", false);;
let f (x,y,z) = (x, string_of_int x ^ y, not z);;
f xxx;;
f yyy;;
let zzz = (3, ("45", true)) and ttt = ((3, "45"), true);;
xxx = zzz or xxx = ttt;;

type t = {x : int; y : int; z : string list};;
let rec1 = {x = 3; z = ["2"]; y = 1};;
let rec2 = {x = 3; y = 1; z = ["2"]};;
rec1 = rec2;;
type t' = {xxx : int; yyy : t};;
let rec3 = {xxx = 1; yyy = {x = 4; y = 5; z = []}};;
rec3.yyy.z;;
type t'' = {x : int};;
let rec4 = {x = 6};;
rec2.x + rec4.x;;

type C = C1 | C2 | C3 of int * float * string list;;
let x = C3(1, 1.2, ["aaa"; "bbb"]);;
let f = function 
   | C1 -> 1
   | C3(x,y,z) -> x
   | C2 -> 0;;
f x;;
type C' = C1 | C3 of int * float * string list;;
f x;;
let g = function
   | C1 -> 1
   | C3(x,y,z) -> x;;
g x;;

Exercice 2

Quel est le type de la fonction suivante et que fait elle :

let inconnue l =
   let rec inconnue_rec = function
      | [] -> l
      | x::reste -> (inconnue_rec reste) @ [x]
   in
      if l = [0] then []
      else inconnue_rec l;;

Exercice 3 (Représentation d'un jeu de cartes)

Dans le présent exercice ainsi que dans les suivants, vous allez progressivement programmer les premisses d'un arbitre pour jouer à la belote. Pour l'instant, votre but est de modéliser en camllight le jeu de 32 cartes servant à la belote.

1. Une carte est définie par sa couleur (carreau, coeur, pique, trèfle) et sa hauteur (as, roi, dame, valet, dix, neuf, huit, sept). Définissez les types énumérés couleur et hauteur à cet effet.

2. Définissez le type carte comme un enregistrement contenant les informations de couleur et de hauteur.

3. Définissez les valeurs représentant l'as de trèfle, la dame de coeur et le 8 de carreau.

4. En utilisant le type list prédéfini en camllight, définissez le type main représentant un ensemble (une liste) de cartes.

5. En quoi le type main ne répond t-il pas entièrement à la question ? Donnez un contre-exemple.

Exercice 4 (Le comptage des points)

En fin de partie, les cartes sont évaluées de la façon suivante : quelle que soit la couleur de l'atout, l'as vaut 11 points, le roi vaut 4 points, la dame vaut 3 points, le dix vaut 10 points, le huit et le sept ne valent aucun point. Dans la couleur de l'atout, le valet vaut 20 points et le 9 vaut 14 points, mais dans les autres couleurs, le valet ne vaut que 2 points et le 9 ne vaut rien du tout.

1. Écrivez une fonction valeur donnant la valeur d'une carte. Commencez par réfléchir au type que devra posséder cette fonction.

2. Utilisez la fonction précédente pour définir une fonction valeur_main donnant la valeur d'une liste de cartes.

Exercice 5 (Le rangement des cartes)

Dans cet exercice, on souhaite ranger une main par couleur et par valeur (on rappelle que la valeur d'une carte dépend de sa couleur). L'ordre souhaité pour les couleurs est celui du bridge (Trèfle, Carreau, Coeur, Pique).

1. Écrivez un prédicat inf qui retourne le booléen true si son premier argument est une carte devant être placée avant la carte donnée en second argument.

2. Écrivez une fonction insere qui introduit une carte à l'endroit souhaité dans une main déjà convenablement rangée.

3. Écrivez une fonction range qui classe une main.

Exercice 6 (Le tirage des cartes)

Par définition, l'ensemble des cartes d'un jeu est en bijection avec l'intervalle [0,31] des entiers.

1. Définissez formellement une telle bijection (il y a bien entendu plus d'une réponse possible). Définissez alors en camllight au moyen de deux fonctions cartes_of_int et int_of_cartes cette bijection.

2. Que fait la fonction foo suivante :

let foo () = 
   let rec foo_rec i =
      if i = 32 then []
      else i::(foo_rec (i+1))
   and foo_rec2 i l =
      if i = 32 then l
      else
         let n = random__int (32-i) in
         let l' = map (function x -> if x = n then i
                                     else if x = i then n
                                     else x) l in
         foo_rec2 (i+1) l'
   in let l = foo_rec 0 in
      foo_rec2 0 l;;

3. Écrivez la fonction tirage qui génère une distribution du jeu de 32 cartes sous la forme d'une liste de cartes.

Exercice 7 (La représentation d'un jeu)

La belote est un jeu qui se joue à quatre joueurs usuellement désignés sous les noms de Nord, Sud, Est et Ouest. Les joueurs opposés géographiquement sont dans la même équipe. En début de partie, chaque joueur reçoit 8 cartes et une couleur est désignée comme celle de l'atout. Dans un tour, chacun joue une carte et l'équipe qui remporte le pli, le place dans son talon afin que les points soient comptés en fin de partie.

1. En tenant compte des informations précédentes, définissez le type de données jeu représentant l'état d'une partie à la fin d'un pli.

2. Écrivez la fonction initialise créant une situation de début de partie.

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