Discussion :

[funtix]

Salut !!!
En (re)lisant le bouquin "Développement d'applications avec Objective Caml", je suis tombé sur les définitions de types qui tournent autour des jeux de cartes.
Comme en ce moment je m'essaye au poker en ligne, je me suis dit : "tiens si je me développais ma p'tite appli qui calcule pour moi les probabilités de gagner avec une main donnée!!!"
Donc mon objectif, implémenter en o'caml un jeu de poker.
Je suis à la recherche d'idées car je bute sur un premier problème. Comment évaluer une main dans un esprit plus fonctionnel qu'impératif ??? C'est à dire connaissant un ensemble de cartes, déduire la combinaison (Paire, Double paire, brelan, ...) la plus élevée. J'avoue que j'ai du mal à me détacher de mon mode de pensée procédurale.( par manque de pratique)
Alors, dans le style caml, quelles sont vos propositions ?
Merci.

[LLB]

Tu pourrais donner la solution impérative que tu as en tête ? Ce sera plus simple pour t'expliquer comment la transformer, je pense.

À quel endroit se pose le problème ? C'est pour détecter une combinaison ? Ou récupérer la meilleure ? Ou... ?

[Garulfo]

Salut !!!
[...]
Je suis à la recherche d'idées car je bute sur un premier problème. Comment évaluer une main dans un esprit plus fonctionnel qu'impératif ??? C'est à dire connaissant un ensemble de cartes, déduire la combinaison (Paire, Double paire, brelan, ...) la plus élevée. J'avoue que j'ai du mal à me détacher de mon mode de pensée procédurale.( par manque de pratique)
Alors, dans le style caml, quelles sont vos propositions ?
Merci.

Attention à ne pas confondre (définitions succintes et grossières)
programmation impératif : les données peuvent être modifiées dans le cours du programme
programmation procédurale : utilisation de fonctions/procédures
programmation fonctionnelle : la fonction est une donnée de base comme les autres données.

Comme tu le vois, on peut être procédurale et fonctionnelle. On peut aussi faire de l'impératif et du fonctionnelle (même si ça va mal ensemble car il y a d'autres éléments du paradigmes qui vont mal ensemble).

En fait, un point important dans une conception est de faire les choses de la manière la plus naturelle (pour soi) possible. Si c'est un calvaire à penser en fonctionnelle pur et dur alors c'est peut être aussi une mauvaise idée.

Mais dans ton cas, tu veux partir d'un programme tout fait on dirait. Donc forcément, c'est difficile. Par plutôt d'une conception (une bonne, i.e. qui n'est pas faite pour un langage en particulier) et ce sera peut être plus facile.

[Jedai]

Comme tu le vois, on peut être procédurale et fonctionnelle. On peut aussi faire de l'impératif et du fonctionnelle (même si ça va mal ensemble car il y a d'autres éléments du paradigmes qui vont mal ensemble).

Ca dépend de ce que tu mets dans "fonctionnel", personnellement j'y met aussi la transparence référentielle, qui ne s'accorde pas vraiment avec l'impératif...
(La programmation procédurale implique également un séquencement des actions qui n'est pas part du fonctionnel pur, et évidemment une non-transparence référentielle pour les procédures)

En tout cas il serait intéressant de savoir à quoi funtix pense initialement. Pour ma part je vois au moins deux modèles de solution : d'une part simplement prendre la partie de la main qui a le meilleur score parmi toutes les parties de l'ensemble des cartes de la main (envisageable surtout s'il y a peu de cartes, je n'ai jamais joué au poker), d'autre part, créer des fonctions qui reconnaissent les combinaisons comme par exemple une fonction qui trouve l'ensemble des paires de la main, l'ensemble des brelans, l'ensemble des suites... Sans doute préférable s'il y a trop de cartes dans une main.

--
Jedaï

[Garulfo]

Ca dépend de ce que tu mets dans "fonctionnel", personnellement j'y met aussi la transparence référentielle, qui ne s'accorde pas vraiment avec l'impératif...
(La programmation procédurale implique également un séquencement des actions qui n'est pas part du fonctionnel pur, et évidemment une non-transparence référentielle pour les procédures)
[..]
--
Jedaï

Comme je l'ai dit, par convention, la programmation fonctionnelle c'est avant tout le fait de traiter les fonctions comme les autres données. Mais c'est vrai que souvent on met l'emphase sur l'appel de fonction plutôt que le changement d'état (d'où une antinomie avec la programmation impérative).
On peut y mettre d'autres caractéristiques, mais au moins celle-ci fait l'unanimité Le séquencement n'est pas forcément procédurale non plus, c'est de la programmation structurée.
La transparence réferentielle n'est absolument pas incompatible avec la notion de procédure. Les procédures n'impliquent pas l'existence d'effet de bord et une programmation modulaire impliquant justement la limitation des effets de bords va faire que tes procédures deviennent des « fonctions mathématiques ».
Mais c'est vrai qu'il n'y a pas de définitions finales cependant. Et beaucoup de personnes y mettent un peu ce qu'elles veulent. C'est pour cela que je n'ai gardé que l'esprit premier de ces définitions. En tout cas, la plupart du temps les techniques ne sont pas incompatibles.

[gasche]

En tout cas il serait intéressant de savoir à quoi funtix pense initialement. Pour ma part je vois au moins deux modèles de solution : d'une part simplement prendre la partie de la main qui a le meilleur score parmi toutes les parties de l'ensemble des cartes de la main (envisageable surtout s'il y a peu de cartes, je n'ai jamais joué au poker), d'autre part, créer des fonctions qui reconnaissent les combinaisons comme par exemple une fonction qui trouve l'ensemble des paires de la main, l'ensemble des brelans, l'ensemble des suites... Sans doute préférable s'il y a trop de cartes dans une main.

La première solution me paraît plus facile à mettre en oeuvre et plus élégante. De plus, à priori il n'y a que 5 cartes dans une main, donc c'est tout à fait jouable.

De plus, l'approche par "parties de main" est à mon avis plus flexible, par exemple on doit pouvoir l'adapter naturellement pour savoir dire "combien de cartes j'ai intérêt à essayer de changer".

[InOCamlWeTrust]

On peut y mettre d'autres caractéristiques, mais au moins celle-ci fait l'unanimité

C'est une définition communément acceptée, mais qui ne me satisfait pas trop en l'état (oui, je sais que tu sais...).

[funtix]

Je n'ai pas eu le temps cette semaine de reflechir a mon probleme...
Je me suis surement mal exprimé dans mon 1er post (je maitrise pas les definitions exactes de procedural, fonctionnel, imperatif, etc...).

En fait ce que je voudrais c'est une solution élégante à ce probleme dans l'esprit OCaml.
J'avais pensé naivement que le pattern matching etait la solution ultime mais sans succes!

Voila ce que j'avais tenté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
let evaluer = function
    (x,x,_,_,_)   ->  Paire x
  | (x,x,y,y,_)   ->  DPaire x y
  | (x,x,x,_,_)   ->  Brelan x
  |  ...

Le motif n'étant pas linéaire, ca ne compile pas. Et puis les patterns ci-dessus sont dependants de l'ordre, ce qui n'est pas bon non plus...

En tout cas il serait intéressant de savoir à quoi funtix pense initialement. Pour ma part je vois au moins deux modèles de solution : d'une part simplement prendre la partie de la main qui a le meilleur score parmi toutes les parties de l'ensemble des cartes de la main (envisageable surtout s'il y a peu de cartes, je n'ai jamais joué au poker), d'autre part, créer des fonctions qui reconnaissent les combinaisons comme par exemple une fonction qui trouve l'ensemble des paires de la main, l'ensemble des brelans, l'ensemble des suites... Sans doute préférable s'il y a trop de cartes dans une main.

Pour info, je parle du poker texas holdem.
Tu as 2 cartes cachées en main et 5 cartes ouvertes sur le tapis qui sont dévoilées en temps.
1) Le flop où 3 cartes sont découvertes
2) puis le turn, avec 1 carte
3) et enfin la river, avec la derniere carte

Pour revenir a ce que tu disais, je pensais comme toi, a creer des fonctions pour detecter chaque combinaison du poker possible (is_paire, is_dpaire, is_brelan,etc...). Meme ca je ne vois pas trop comment faire (sans algo iteratif avec recherche d'une carte)!


Mais je preferais ta premiere solution

[SpiceGuid]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let evaluer = function
    (x,x,_,_,_)   ->  Paire x
  | (x,x,y,y,_)   ->  DPaire x y
  | (x,x,x,_,_)   ->  Brelan x
  |  ...

Ce code témoigne de ce que ta maîtrise du langage n'est pas à la hauteur des objectifs que tu t'es fixé. Je ne saurais que te conseiller de lire davantage de tutoriels, comme celui de ma signature, ou bien encore:

• Développement d'Applications
• Algorithmique
• Le primeur Caml
• La lettre de Caml

Les textes en anglais ne sont pas inutiles non plus.

OCaml ne t'empêche pas de le faire de façon impérative si tu trouves cela plus facile. Seulement alors c'est de l'impératif, donc c'est plus difficile.

[funtix]

Ce code témoigne de ce que ta maîtrise du langage n'est pas à la hauteur des objectifs que tu t'es fixé.

Clairement

Avant cela, j'ai lu quelques unes des références citées mais très peu pratiqué. J'ai juste fait un programme de classement de spam. Et puis ocaml est tombé aux oubliettes comme de nombreuses fois... Mais je persiste et reprend en me penchant sur ce probleme de poker. Ya qu'en pratiquant (et en discutant) qu'on progresse.

[DavidDeharbe]

Salut !!!
En (re)lisant le bouquin "Développement d'applications avec Objective Caml", je suis tombé sur les définitions de types qui tournent autour des jeux de cartes.
Comme en ce moment je m'essaye au poker en ligne, je me suis dit : "tiens si je me développais ma p'tite appli qui calcule pour moi les probabilités de gagner avec une main donnée!!!"
Donc mon objectif, implémenter en o'caml un jeu de poker.
Je suis à la recherche d'idées car je bute sur un premier problème. Comment évaluer une main dans un esprit plus fonctionnel qu'impératif ??? C'est à dire connaissant un ensemble de cartes, déduire la combinaison (Paire, Double paire, brelan, ...) la plus élevée. J'avoue que j'ai du mal à me détacher de mon mode de pensée procédurale.( par manque de pratique)
Alors, dans le style caml, quelles sont vos propositions ?
Merci.

Je propose le code suivant. Je ne connais pas les règles du jeu en détail et me suis contenté de définir des types pour représenter les cartes et les différentes mains possibles. Il ne s'agit donc que d'un point de départ. Je pense qu'une première amélioration serait de paramétrer le type ranking_t avec l'information qui permet de résoudre les égalités (couleur dans le cas d'une straight flush, par exemple).

Critiques (constructives) sont toujours les bienvenues!...

David.
--

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
(* a type for card suits *)
type suit_t = Spades | Hearts | Diamonds | Clubs
(* a type for card values *)
type value_t = Pip of int | King | Queen | Jack | Ace
(* a type for (poker) cards *)
type card_t = { suit : suit_t ; value : value_t }
(* a list of all the possible card values *) 
let values =
  [ Pip(2); Pip(3); Pip(4); Pip(5); Pip(6); Pip(7); Pip(8); Pip(9); Pip(10);
    Jack; Queen; King; Ace ]
(* a list of all the possible card suits *)
let suits =
  [ Spades; Hearts; Diamonds; Clubs ]
 
 
(* a type for poker hands (five cards?) *)
type hand_t = card_t * card_t * card_t * card_t * card_t
 
(* example of a hand - no other purpose than illustration *)
let h1 : hand_t = 
  { value = Pip(2); suit = Hearts },
  { value = Pip(2); suit = Spades },
  { value = Pip(3); suit = Clubs },
  { value = Pip(5); suit = Hearts },
  { value = Ace; suit = Diamonds }
 
(* utility function to convert boolean to ints { true -> 1, false -> 0 } *)
let int_of_bool : bool -> int = 
  function 
      true -> 1
    | false -> 0
 
(* counts the number of cards in a hand that satisfy criterion "getter(card) = select", where getter is a function and select a value. *)
let count_of (hand: hand_t) (getter: card_t -> 'a) (select: 'a) =
  match hand with
      (c1, c2, c3, c4, c5) -> (int_of_bool((getter c1) = select) +
				 int_of_bool((getter c2) = select) +
				 int_of_bool((getter c3) = select) +
				 int_of_bool((getter c4) = select) +
				 int_of_bool((getter c5) = select))
 
(* returns a list of number of cards of each possible value in a hand *)
let count_hand_values: hand_t -> int list =
  function hand -> List.map (count_of hand (fun h -> h.value)) values
 
(* returns a list of number of cards of each possible suit in a hand *)
let count_hand_suits: hand_t -> int list =
  function hand -> List.map (count_of hand (fun h -> h.suit)) suits
 
(* a type for poker rankings - may need to be parameterized to handle draws *)
type ranking_t = HighCard | OnePair | TwoPair | ThreeOfAKind | Straight | Flush | FullHouse | FourOfAKind | StraightFlush | RoyalFlush
 
(* returns the maximum value of a non-empty list *)  
let rec list_max : int list -> int =
  function 
      [ n ] -> n
    | hd :: tl -> max hd (list_max tl)
 
(* checks if a list of integers contains five consecutive ones; the list
must correspond to a result of the application of count_hand_values. *)
let rec list_straight : int list -> bool =
  function
    | 1 :: 1 :: 1 :: 1 :: 1 :: tl -> true
    | 0 :: tl -> list_straight tl
    | _ -> false
 
(* checks if a list of integers ends with five consecutive ones; the list
must correspond to a result of the application of count_hand_values. *)
let rec list_royal_flush : int list -> bool =
  function
    | 1 :: 1 :: 1 :: 1 :: 1 :: [] -> true
    | 0 :: tl -> list_royal_flush tl
    | _ -> false
 
(* checks if a list of integers contains one 3, one 2 and 0s; the list
must correspond to a result of the application of count_hand_values. *)
let rec full_house : int list -> bool =
  function
      0 :: tl -> full_house tl
    | 3 :: tl -> list_max tl = 2
    | 2 :: tl -> list_max tl = 3
    | _ -> false
 
(* checks if a list of integers contains two 2s and 0s; the list
must correspond to a result of the application of count_hand_values. *)
let rec two_pair : int list -> bool =
  function
      0 :: tl -> two_pair tl
    | 2 :: tl -> list_max tl = 2
    | _ -> false
 
(* given a hand returns the (highest) ranking according to the rules of poker *)
let ranking_of_hand : hand_t -> ranking_t =
  function h ->
    let values = count_hand_values h and suits = count_hand_suits h in
      if list_straight values then
	if list_max suits = 1 then
	  if list_royal_flush values then RoyalFlush
	  else Flush
	else Straight
      else let m = list_max values in
	if m = 4 then FourOfAKind
	else if m = 3 && full_house values then FullHouse
	else if list_max suits = 1 then Flush
	else if m = 3 then ThreeOfAKind
	else if m = 2 && two_pair values then TwoPair
	else if m = 2 then OnePair
	else HighCard

[SpiceGuid]

Je n'y connais rien au poker mais ça me paraît un très bon début.

Dans ton type ranking_t il faut ajouter des paramètres, essentiellement value_t, après cette amélioration tu dois pouvoir comparer deux mains.

[SpiceGuid]

J'ai craqué je suis allé voir sur http://fr.wikipedia.org/wiki/Poker.

Comme on a jack < queen < king < ace il suffit de déclarer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
let jack  = 20
and queen = 30
and king  = 40
and ace   = 50
;;

Les autres cartes auront simplement leur valeur numérique.
Ensuite on classe tout du plus grand au plus petit, et on déclare:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
type poker_hand =
  | StraightFlush of int
  | FourOfAKind of int * int
  | FullHouse of int * int
  | Flush of int
  | Straight of int
  | ThreeOfAKind of int * int * int
  | TwoPair of int * int * int
  | OnePair of int * int * int * int
  | HighCard of int * int * int * int * int
  ;;

Quand je dis on classe tout du plus grand au plus petit cela veut dire plusieurs choses:

• StraightFlush > FourOfAKind > FullHouse > Flush > Straight > ThreeOfAKind > TwoPair > OnePair > HighCard
• FullHouse(a,b) désigne un brelan de a plus une paire de b
• ThreeOfAKind(a,b,c) désigne un brelan de a plus 2 cartes b et c telles que b > c
• TwoOfAKind(a,b,c,d) désigne une paire de a plus 3 carte b, c et d telles que b > c > d
• StraightFlush of a, Flush of b et Straight of c désignent respectivement une Quinte-flush, une Main-Pleine et une Couleur de hauteur respective a, b et c
• HighCard(a,b,c,d,e) désigne une main dans laquelle a > b > c > d > e

Je vous laisse écrire la fonction qui compare deux mains et qui n'est plus qu'une comparaison en ordre lexicographique.

EDIT:

Le type card devient simplement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
type card =
  | Spades of int
  | Hearts of int
  | Diamonds of int
  | Clubs of int
  ;;

[DavidDeharbe]

Dois-je en déduire qu'il y a un ordre implicite sur les types variants, qui est celui de déclaration?

Suite à la déclaration suivante, A > B est évalué à true?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type t = A | B

[funtix]

Merci David
Je vais regarder ca ce week end.
Je m'attendais a davantage de lignes de code . C'est top ocaml

[SpiceGuid]

@David

Oui, si j'ai une paire et que tu as un brelan c'est facile de décider le gagnant.
L'ordre lexicographique c'est la façon de comparer deux chaînes de caratères, par exemple "baba" < "blabla" parce que "b"="b" mais "a"<"l". C'est pourquoi il faut ordonner la main en ordre lexicographique, si j'ai OnePair(queen,king,jack,7) et que tu as OnePair(queen,king,jack,10), alors ce n'est pas la paire qui décide, ni le roi, ni le valet, c'est la plus petite carte, le 10 l'emporte contre le 7.

@funtix

Oui c'est inspirant comme code mais comme le type n'est pas complet toutes les fonctions sont à revoir.

[DavidDeharbe]

Merci, je connais bien l'ordre lexicographique. Je ne savais pas qu'il s'appliquait aux tuples. Mais ma question portait sur les types variants et reste ouverte.

David.
--

[DavidDeharbe]

Merci David
Je vais regarder ca ce week end.
Je m'attendais a davantage de lignes de code . C'est top ocaml

Je ne connais les règles du poker que de manière superficielle, mais je te rappelle qu'il faut redéfinir le type ranking_t et y ajouter le critère pour décider du vainqueur en cas d'égalité. Tu peux faire cela en rajoutant un paramêtre aux constructeurs du type ranking_t. Une autre possibilité serait de constituer un type registre ou paire où le premier élément serait le nom de la combinaison la plus haute (du type ranking_t, donc) et le second élément une information qui te permet de décider le vainqueur (la carte la plus "haute" par exemple).

David.
--

[SpiceGuid]

@David

J'ai corrigé ma déclaration:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
let jack  = 20
and queen = 30
and king  = 40
and ace   = 50
;;
 
type poker_hand =
  | HighCard of int * int * int * int * int
  | OnePair of int * int * int * int
  | TwoPair of int * int * int
  | ThreeOfAKind of int
  | Straight of int
  | Flush of int * int * int * int * int
  | FullHouse of int * int
  | FourOfAKind of int
  | StraightFlush of int
  ;;

La fonction compare ainsi que les opérateurs de comparaison utilisent l'ordre lexicographique sur les n-uplets (les expressions suivantes renvoient true):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
HighCard(king,queen,jack,10,7) > HighCard(king,queen,jack,10,5);;
OnePair(queen,king,jack,10) > OnePair(queen,king,jack,7);;
FullHouse(queen,jack) > FullHouse(queen,10);;

et la quinte au huit bat la quinte au six:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Straight(8) > Straight(6);; 
- : bool = true

Ceci vaut également pour les variants (le variant qui précède est inférieur au variant qui succède), par exemple le brelan de 2 bat une paire de reines:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# ThreeOfAKind(2) > OnePair(queen,king,jack,10);;
- : bool = true

et la quinte-flush au six bat la quinte au huit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
StraightFlush(6) > Straight(8);; 
- : bool = true

[funtix]

Dois-je en déduire qu'il y a un ordre implicite sur les types variants, qui est celui de déclaration?

Suite à la déclaration suivante, A > B est évalué à true?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
type t = A | B

SpiceGuid, tu réponds oui (en fait c'est l'inverse. C'est B qui est superieur a A). Je découvre, c'est cool.

J'ai fait quelques essais avec le type suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
type value =  Value of int
            | Valet
            | Dame
            | Roi
            | As

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
Valet > Dame;;
- : bool = false
Dame > Valet;;
- : bool = true

Mais avec le type Value ca ne fonctionne pas!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Value 5 > Dame;;
- : bool = true