représentation des cartes en Prolog

Question

Je suis en train d'apprendre Prolog. Ce sont mes premiers pas avec cette langue. Comme exercice, je veux programme d'écriture qui peut reconnaître des mains de poker (Straight flush, quatre d'une sorte, maison pleine etc.).

Je cherche une bonne représentation de la carte dans Prolog. Je dois avoir la possibilité de vérifier si une carte est plus grande que les autres, si les cartes sont adaptées et si l'un.

J'ai commencé avec le code:

rank(2).
rank(3).
rank(4).
rank(5).
rank(6).
rank(7).
rank(8).
rank(9).
rank(t).
rank(j).
rank(q).
rank(k).
rank(a).

value(2, 2).
value(3, 3).
value(4, 4).
value(5, 5).
value(6, 6).
value(7, 7).
value(8, 8).
value(9, 9).
value(t, 10).
value(j, 11).
value(q, 12).
value(k, 13).
value(a, 14).
%value(a, 1).

suite(d).
suite(h).
suite(c).
suite(s).

rank_bigger(X, Y) :-
               value(X, A),
               value(Y, B),
               A > B.

Ce give mi possibilité de vérifier si le rang A est plus grand que par exemple J.

Mais je ne sais pas comment représenter seule carte. Cette représentation devrait contenir le rang de la carte et aussi costume. Il y a aussi un certain problème avec Ace parce que Ace ont rang 14, mais il peut aussi être 1 en droit.

Alors, ma question est de savoir comment représente les cartes si je veux faire des règles comme:

isStraight(C1, C2, C3, C4, C5) :- 
                                  [...]

ou

isStraightFlush(C1, C2, C3, C4, C5) :- 
                                       [...]

Je suis sûr que ce genre de question simple si vous connaissez la langue, mais il est pas si facile de penser « switch » de langages comme C ou python. : -)

Answer 1

Vous pourriez représenter des cartes comme des termes avec la forme Rank-Suite.

Afin de vérifier si les cartes proviennent de la même suite définir un prédicat:

same_suit(_-S, _-S).

Vous pouvez utiliser ce prédicat pour vérifier si vous avez une chasse d'eau:

?- Cards = [1-d, 2-d, 3-d, 4-d, 5-d], maplist(same_suit(_-S), Cards).
Cards = [1-d, 2-d, 3-d, 4-d, 5-d],
S = d.

Afin de détecter si vous avez une paire, deux paires, trois d'une sorte, maison pleine, ou quatre d'une sorte que vous pouvez simplement compter le nombre de paires dans la main et la carte le résultat au nom de la main.

% Count the number of pairs in the given list of cards.
count_pairs([], 0).

count_pairs([R-_ | Cs], Pairs) :-
    count_rank(R, Cs, RankCount),
    count_pairs(Cs, Pairs0),
    Pairs is RankCount + Pairs0.


% Count the number of cards with the given rank
count_rank(R, Cs, RankCount) :-
    count_rank(R, Cs, 0, RankCount).


count_rank(_, [], RankCount, RankCount) :- !.

count_rank(R, [R-_ | Cs], RankCount0, RankCount) :-
    !,
    RankCount1 is RankCount0 + 1,
    count_rank(R, Cs, RankCount1, RankCount).

count_rank(R, [_ | Cs], RankCount0, RankCount) :-
    count_rank(R, Cs, RankCount0, RankCount).


% Map the number of pairs to the name of the hand
pairs_hand(1, one_pair).
pairs_hand(2, two_pair).
pairs_hand(3, three_of_a_kind).
pairs_hand(4, full_house).
%pairs_hand(5, 'NOT POSSIBLE').
pairs_hand(6, four_of_a_kind).

Exemples d'utilisation:

?- count_pairs([q-c, q-d, q-s, j-s, q-h], PairsCount), pairs_hand(PairsCount, Hand).
PairsCount = 6,
Hand = four_of_a_kind.

?- count_pairs([j-c, q-d, q-s, j-s, q-h], PairsCount), pairs_hand(PairsCount, Hand).
PairsCount = 4,
Hand = full_house.

?- count_pairs([j-c, q-d, q-s, j-s, 7-h], PairsCount), pairs_hand(PairsCount, Hand).
PairsCount = 2,
Hand = two_pair.

Answer 2

Vous pouvez utiliser pour faire des programmes jolis unicode et SWI ...

:- op(200, xf, ♥).
:- op(200, xf, ♦).
:- op(200, xf, ♣).
:- op(200, xf, ♠).
:- op(200, xf, ♡).
:- op(200, xf, ♢).
:- op(200, xf, ♧).
:- op(200, xf, ♤).

main :- print([2♠,3♦,'K'♥,10♠,3♣]),
        isFlush(2♠,3♦,'K'♥,10♠,3♣).

isFlush(♥(_),♥(_),♥(_),♥(_),♥(_)).
isFlush(♦(_),♦(_),♦(_),♦(_),♦(_)).
isFlush(♣(_),♣(_),♣(_),♣(_),♣(_)).
isFlush(♠(_),♠(_),♠(_),♠(_),♠(_)).

Answer 3

Utiliser une liste de paires, card(rank, suite) pour la main. Définir prédicats pour compter le nombre de fois que chaque rang est répété dans une main, une sorte inverse en nombre, et vous avez le poker en [4,1], plein [3,2], trio [3|_], etc. Un peu plus de travail avec le tri et le comptage révélera et Bouffées lignes droites. Au lieu de valeurs numériques, les relations d'utilisation higher(a,b) et equal(a,b) qui appliquent aux deux rangs et les mains (et à des poursuites, si cette règle s'applique).

Parce qu'il ya seulement cinq cartes dans une main, vous pouvez vous en sortir avec les possibilités au lieu énumération de tri ... votre choix.

Note:. J'ai retiré les échantillons de code parce qu'ils contenaient trop d'erreurs de syntaxe et de logique