Tarjetas representación en Prolog

Question

Estoy tratando de aprender Prolog. Estos son mis primeros pasos con este lenguaje. Como ejercicio Quiero programa de escritura que puede reconocer algunas manos de póquer (escalera de color, de una clase, la casa completa, etc.).

Estoy buscando una buena representación de cartón en Prolog. Necesito tener posibilidad de comprobar si una tarjeta es más grande que la otra, si las tarjetas son adecuados y así uno.

He empezado con código:

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.

que dan mi posibilidad de comprobar si rango A es más grande que, por ejemplo, J.

Pero no estoy seguro de cómo represento sola tarjeta. Esta representación debería contener rango de tarjeta y también su ejemplo. También hay algún problema con Ace Ace porque tiene rango 14, pero puede ser también recta en 1.

Así que mi pregunta es cómo se representa tarjetas si quiero hacer reglas como:

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

o

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

Estoy seguro de que esto es una especie de simple pregunta si sabe el idioma, pero no es tan fácil pensar 'interruptor' de lenguajes como C o Python. : -)

Answer 1

Se puede representar como tarjetas de acuerdo con la forma Rank-Suite.

Con el fin de comprobar si las tarjetas vienen de la misma suite definir un predicado:

same_suit(_-S, _-S).

Se puede usar este predicado para comprobar si tiene un color:

?- 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.

Con el fin de detectar si usted tiene un par, dos pares, tres de una clase, full, o cuatro de una clase que sólo puede contar el número de pares en la mano y luego el mapa el resultado con el nombre de la mano.

% 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).

Ejemplos de uso:

?- 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

Se puede utilizar Unicode y SWI para hacer programas bonitas ...

:- 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

Usar una lista de pares, card(rank, suite) para la mano. Definir los predicados para contar el número de veces que se repite cada rango en una mano, más o menos inversamente según el recuento, y usted tiene el póker en [4,1], lleno de [3,2], trío en [3|_], etc. Un poco más de trabajo con la clasificación y recuento revelará sofocos y rectas. En lugar de valores numéricos, las relaciones de uso y higher(a,b) equal(a,b) que se aplican a ambas filas y las manos (y para trajes, si se aplica la regla).

Debido a que sólo hay cinco cartas en una mano, que puede salirse con la enumeración de las posibilidades en lugar de la clasificación ... su elección.

Nota:. Quité los ejemplos de código porque contenían demasiados errores de sintaxis y lógica