Univ. Lille1 - Licence Informatique 2ème année 2014-15 Algorithmes et Programmation Impérative 2 Les types somme 1 Préparation du TP Dans le prochain TP, vous allez réaliser un programme de jeu de poker (très simplié). Ce programme sera réalisé en quatre parties 1. un module Carte qui déclare un type pour représenter les 52 cartes d'un jeu de poker, ainsi que quelques fonctions ; 2. un module Main qui déclare un type pour représenter une main de 5 cartes, ainsi que quelques fonctions ; 3. un module Combinaison qui déclare un type pour représenter les combinaisons possibles présentées par une main de 5 cartes, ainsi que quelques fonctions ; 4. un programme principal, qui simule une partie. Les sections qui suivent présentent les interfaces de ces diérents composants. 2 Interface du module Carte 2.1 Les types de donnees type hauteur type couleur type carte 2.2 Constructeur et selecteurs val cree : char -> int -> carte cree s n renvoie une carte dont la couleur est donnee par s et la hauteur par n. CU : s ne peut prendre que l'une des quatre valeurs T pour tree P pour pique K pour carreau C pour coeur Sinon, declenchement de l'exception Failure "Carte.cree : couleur non valide". n doit etre un entier compris entre 1 et 13 avec la correspondance 1 pour un as 11 pour un valet 12 pour une dame 13 pour un roi les autres valeurs representant elles-memes. Sinon, declenchement de l'exception Failure "Carte.cree : hauteur non valide". val couleur : carte -> couleur 1
couleur c renvoie la couleur de la carte c. val hauteur : carte -> hauteur hauteur c renvoie la hauteur de la carte c. 2.3 Fonctions de comparaison val hauteurs_consecutives : hauteur -> hauteur -> bool hauteurs_consecutives h1 h2 = true si les deux hauteurs sont consecutives dans l'ordre croissant false sinon val compare_hauteurs : hauteur -> hauteur -> int compare_hauteurs h1 h2 compare les hauteurs h1 et h2. = -1 si la hauteur h1 est plus petite que h2 = 1 si la hauteur h1 est plus grande que h2 = 0 si les hauteurs sont egales. val compare_cartes : carte -> carte -> int compare_cartes c1 c2 compare les hauteurs des cartes c1 et c2. = -1 si la hauteur de c1 est plus petite que celle de c2 = 1 si la hauteur de c1 est plus grande que celle de c2 = 0 si les hauteurs sont egales. Remarque : on peut aussi tester l'egalite de deux cartes avec l'operateur =. 2.4 Procedures d'impression val imprimer_couleur : couleur -> unit imprimer_couleur c imprime la couleur c. Un tree est imprime T, un pique P, un carreau K et un coeur C. val imprimer_hauteur : hauteur -> unit imprimer_hauteur imprime la hauteur h. val imprimer_carte : carte -> unit imprimer_carte c imprime la carte c. L'ipression se fait sur deux caracteres : le premier pour la hauteur et le second pour la couleur. L'impression d'un roi de carreau produit donc RK. 2.5 Constructions de paquet de cartes val paquet_ordonne : unit -> carte array paquet_ordonne () renvoie un tableau contenant les 52 cartes d'un jeu de poker. Ces cartes sont rangees par couleurs T, C, P, K, puis au sein d'une couleur dans l'ordre As, 2, 3,..., Roi. val battre_paquet : unit -> carte array battre_paquet () renvoie un tableau contenant les 52 cartes d'un jeu de poker dans un ordre quelconque. 2
3 Interface du module Main 3.1 Le type de donnees type main Une main est un ensemble de cinq cartes dierentes d'un jeu de poker. 3.2 Constructeur et selecteur val cree : Carte.carte * Carte.carte * Carte.carte * Carte.carte * Carte.carte -> main cree (c1,c2,c3,c4,c5) cree une main avec les cinq cartes donnees. val carte : main -> int -> Carte.carte carte m i renvoie la carte de rang i dans l'ordre croissant dans la main m. Les cartes carte m 1, carte m 2, carte m 3, carte m 4, carte m 5 sont les cinq cartes de la main m et leurs hauteurs sont dans l'ordre croissant. CU : l'entier i doit etre compris entre 1 et 5. Sinon, declenche l'exception Failure "Main.carte : indice incorrect". 3.3 Procedure d'impression val imprimer : main -> unit imprimer m imprime la main m. Par exemple, l'impression a la forme [ 2C, 3K, 8K, 9K, RP] 3.4 Divers val main_alea : unit -> main main_alea () renvoie une main de cinq cartes choisies aleatoirement dans un jeu de 52 cartes. val distribue : int -> main array distribue n renvoie un tableau de n mains extraites d'un jeu de 52 cartes. CU : l'entier n doit etre compris entre 2 et 5. Sinon, declenche l'exception Failure "Main.distribue : nombre joueurs incorrect". 4 Interface du module Combinaison 4.1 Le type de donnees type combinaison Au poker, les combinaisons d'une main peuvent etre dans l'ordre decroissant de valeur : une quinte ush 3
un carre un full une couleur une suite un brelan une double paire une paire une main vide (aucune combinaison) 4.2 Procedure d'impression d'une combinaison val imprimer : combinaison -> unit imprimer c imprime la combinaison c. 4.3 Evaluation d'une main au poker val evalue : Main.main -> combinaison evalue m donne la combinaison de valeur maximale presente dans la main m. 4.4 Comparaison de combinaisons val compare : combinaison -> combinaison -> int compare c1 c2 = -1 si la combinaison c1 est inferieure a la combinaison c2 = 1 si la combinaison c1 est superieure a la combinaison c2 = 0 si les deux combinaisons sont de meme niveau. 5 Le programme Jeu 5.1 Fonction de classement des joueurs val evalue_distribution : Main.main array -> (int * Combinaison.combinaison) array evalue_distribution d calcule les combinaisons de chacun des joueurs. 5.2 Une procédure pour indiquer l'usage du programme val usage : unit -> a 5.3 La procédure principale val principal : unit -> a L'instruction principal () est chargee de verier le nombre de parametres de simuler une donne de n mains et d'indiquer le joueur gagnant 4
6 Préparation 6.1 Organisation générale du programme Question 1 Au vu de la documentation des interfaces, indiquez sous forme d'un graphe les dépendances entre modules. Par exemple, le schéma A B signie que le module A utilise des déclarations du module B. Question 2 En déduire dans quel ordre doivent être compilés les modules. 6.2 Le module Carte Question 3 Question 4 Question 5 Proposez une dénition pour chacun des trois types. Donnez des raisons qui peuvent justier de rendre abstraits ces types. Réalisez le constructeur cree, ainsi que les deux sélecteurs couleur et hauteur. Pour la fonction cree, il peut être utile de disposer d'un tableau contenant toutes les hauteurs. Question 6 Question 7 Question 8 Question 9 Réalisez la fonction hauteurs_consecutives. Réalisez les fonctions compare_hauteurs et compare_cartes. Réalisez les procédures d'impression. Réalisez la fonction paquet_ordonne. Question 10 Pour la réalisation de la fonction battre_paquet, une méthode possible consiste à partir d'un paquet de cartes ordonné (obtenu avec la fonction paquet_ordonne), puis pour chaque position dans ce paquet échanger la carte qui s'y trouve avec une autre carte choisie au hasard. Vous serez donc amené à utiliser la fonction Random.int qui renvoie un entier (pseudo-)aléatoire compris entre 0 et n 1 si n est l'entier passé en paramètre. Rappel : l'usage de procédures de génération d'alea en programmation nécessite toujours une initialisation préalable eectuée une fois pour toute. En Caml, il est possible d'initialiser le générateur d'alea avec la fonction Random.self_init. Il sut donc d'ajouter dans l'implémentation du module une déclaration let _ = Random.self_init () qui assurera que l'initialisation du générateur d'alea est eectuée une fois dans tout programme utilisant le module Carte. 6.3 Le module Main Une main au poker est constituée de cinq cartes. Question 11 A priori, quelle(s) dénition(s) du type main peut-on envisager? Pour des raisons pratiques, en particulier l'implémentation du module Combinaison, il est utile de faire en sorte que la représentation choisie permette d'ordonner les cartes d'une main selon les hauteurs. Une représentation de ce type sous forme de tableau de cartes ordonné selon 5
les hauteurs semble donc une bonne solution. Question 12 Dénissez alors le type main, et réalisez la fonction cree. Vous pourrez utiliser la procédure Array.sort de type ( a a int) a array unit. qui trie dans l'ordre croissant déni par la fonction passée en premier paramètre le tableau passé en second paramètre. Voici un exemple d'utilisation de cette procédure : # let t = [ 3; 1; 5; 0 ] in Array.sort Pervasives.compare t ; t ;; - : int array = [ 0; 1; 3; 5 ] Question 13 Réalisez l'unique sélecteur carte qui permet d'accéder à une carte d'une main selon son rang dans la main dans l'ordre croissant. Question 14 Réalisez la procédure d'impression d'une main. L'impression d'une main s'eectuant sous la forme # let m = cree ((Carte.cree T 1), (Carte.cree C 11), (Carte.cree K 7), (Carte.cree T 9), (Carte.cree K 12)) in imprimer m ;; [ 7K, 9T, VC, DK, AT]- : unit = () Question 15 Réalisez la fonction main_alea. # imprimer (main_alea ()) ;; [ 2T, 4T, 8C, 9T, DK]- : unit = () Question 16 Réalisez la fonction distribue. Question 17 Utilisez les fonctions distribue et imprimer de ce module, ainsi que la fonction Printf.printf, pour imprimer les mains distribuées à quatre joueurs. L'achage aura la forme Joueur 1 :[ 5C, 6T, 7C, VC, AP] Joueur 2 :[ 5C, 6T, 7C, VC, AP] Joueur 3 :[ 5C, 6T, 7C, VC, AP] Joueur 4 :[ 5C, 6T, 7C, VC, AP] 6.4 Le module Combinaison Question 18 Dénissez le type combinaison pour représenter les diérentes combinaisons que peut présenter une main de cinq cartes au poker. Ces combinaisons peuvent être (par ordre décroissant de valeur) : 1. Une quinte ush : cinq cartes de même couleur dont les hauteurs se suivent ; les quintes sont caractérisées par la hauteur de la carte la plus haute ainsi que par la couleur. 2. Un carré : quatre cartes de même hauteur ; les carrés sont caractérisés par la hauteur de ces quatre cartes. 3. Un full : trois cartes de même hauteur, et les deux autres cartes de même hauteur ; les fulls sont caractérisés par les deux hauteurs, celle du brelan d'abord, puis celle de la paire ensuite. 6
4. Une couleur : les cinq cartes sont de la même couleur, mais ne se suivent pas ; les couleurs sont caractérisées par la couleur. 5. Une suite : les cinq cartes se suivent mais ne sont pas toutes dela même couleur ; les suites sont caractérisées par la hauteur de la carte la plus haute. 6. Un brelan : trois cartes sont de la même hauteur, les deux autres cartes étant de hauteurs diérentes ; les brelans sont caractérisés par la hauteur de ces trois cartes. 7. Une double paire : la main contient deux paires de hauteurs diérentes ; les doubles paires sont caractérisées par les hauteurs de ces deux paires, la plus grand hauteur d'abord, l'autre ensuite. 8. Une paire : deux cartes ont la même hauteur, les trois autres cartes sont de hauteurs toutes diérentes ; les paires sont caractérisées par la hauteur de ces deux cartes. 9. Une main vide : rien de particulier dans la main. Question 19 Réaliser une procédure d'impression pour les combinaisons. Voici quelques exemples d'impressions (utilisant la fonction evalue dénie plus tard) Paire de 8- : unit = () Main vide- : unit = () Brelan de D- : unit = () Full de 7 par les A- : unit = () La fonction d'évaluation d'une main pour en déterminer la combinaison qu'elle contient n'est pas simple à réaliser. La solution suggérée ci-dessous consiste à écrire un prédicat (ou fonction booléenne) pour chaque combinaison qui sera satisfait si la main présente cette combinaison. Ces fonctions ne font pas partie de l'interface et ne seront donc pas utilisables à l'extérieur du module. Question 20 Réalisez un prédicat quinte qui détermine si une main est une quinte. Dans le cas, où elle l'est, la fonction renvoie en plus ses caractéristiques, c'estàdire sa couleur et sa hauteur. Commencez par rééchir au type de la valeur renvoyée par cette fonction. Question 21 vide). Faîtes de même pour chacune des autres combinaisons (sauf peut-être pour la main Question 22 Utilisez les prédicats que vous venez de réaliser pour implémenter la fonction evalue. Question 23 Réalisez maintenant la fonction de comparaison des combinaisons. Question 24 Comment utiliser les fonctions evalue et compare pour déterminer le numéro du joueur gagnant, ou des joueurs ex-æquo, dans une distribution de cartes obtenue par la fonction Main.distribue. 7