Il tuo amico ti ha invitato a una partita di poker ad alto rischio all'ultimo minuto e, come informatico, hai deciso di usare le tue abilità per guadagnare un vantaggio sul gioco. Il tuo compito sarà, data 2 cards(la tua mano) e 0, 3, 4 or 5 cards(le carte distribuite), devi decidere quale sarà la migliore mano possibile. Se tutte e 7 le carte vengono fornite come argomenti, la risposta è abbastanza chiara. Se dato di meno, il problema diventa più complesso. Tuttavia, questo non è abbastanza per darti il ​​vantaggio che stai cercando, devi anche calcolare la migliore mano possibile dalle carte rimanenti per capire cosa potrebbero avere anche i tuoi avversari.

Hold'em Refresher

Se non conosci Hold'em, ogni giocatore nel gioco inizia con 2 carte come "mano". Nel corso di 3 "turni", vengono rivelate carte aggiuntive da condividere tra tutti i giocatori. Al primo turno, vengono rivelate 3 carte. La seconda, 1 in più, e la terza volta che viene rivelata una carta finale. Le due carte date per prime rappresentano la tua mano, mentre quest'ultima rappresenta 0, 3, 4 o 5 carte date dai turni successivi.

Numeri possibili:

[2,3,4,5,6,7,8,9,T(10),J,Q,K,A]

Abiti possibili:

[S,C,H,D]

Mazzo completo:

[2S,3S,4S,5S,6S,7S,8S,9S,TS,JS,QS,KS,AS, # Spades.
 2C,3C,4C,5C,6C,7C,8C,9C,TC,JC,QC,KC,AC, # Clubs.
 2H,3H,4H,5H,6H,7H,8H,9H,TH,JH,QH,KH,AH, # Hearts.
 2D,3D,4D,5D,6D,7D,8D,9D,TD,JD,QD,KD,AD] # Diamonds.

Classifiche delle mani:

1:Royal Flush    (A-K-Q-J-10, all from the same suit).
2:Straight Flush (Sequential cards, all from the same suit).
3:Four-of-a-Kind (Self explanatory).
4:Full House     (3-of-a-kind and a 2-of-a-kind).
5:Flush          (All cards are from the same suit).
6:Straight       (Sequential Cards, any suits).
7:3-of-a-Kind    (Self explanatory).
8:2-Pair         (Double 2-of-a-Kind).
9:Pair           (2-of-a-Kind).
10:High Card     (You have absolutely nothing except a single card).

Facciamo un esempio o due e li percorriamo:

Il semplice esempio:

[AS, AC],[AH,AD,9S,9C,9H]-> 3(Four-of-a-Kind), 3(Four-of-a-Kind)

La migliore mano possibile che avrai in questa configurazione è la mano di quattro. La migliore mano possibile che i tuoi avversari potrebbero avere è anche un 4-of-a-Kind, poiché non puoi avere un KQJ10 nelle loro mani da 2 carte.

[5C,2C],[6C,4C,JH,JD]-> 2(Straight Flush), 3(4-of-a-Kind)

Sei a rischio per una scala reale, ma poiché hai i 2 / 5C in mano, nessun altro è dovuto al fatto che hai entrambe le carte centrali. Il meglio che possono sperare è avere 2 jack pocket e ottenere un jack al flop.

[JS,JC],[]-> 1(Scala reale), 1(Scala reale)

Non è stata data alcuna informazione che puoi usare contro di loro, tutto ciò che puoi dire al momento è che possono avere solo una scala reale in diamanti / cuori, ma è altrettanto possibile che tu ottenga la scala reale come loro. In effetti, tutti gli input in cui il flop deve ancora avvenire dovrebbero dare una risposta 1-1.

[2C,4S],[3C,7S,9D,AH,JD]-> 10(Carta alta), 7(3-of-a-Kind)

Questo è un esempio di dove sei assolutamente fregato e non c'è possibilità di una scala o una scala dato il fiume. Ciò significa che la mano migliore in questo caso sono assi tascabili che si traducono in un 3-of-a-Kind.

Requisiti I / O

• L'input deve essere separato tra ciò che è nella tua mano e ciò che è conoscenza pubblica; sarà probabilmente più semplice in questo modo, indipendentemente dall'implementazione.
  • Le carte possono essere tuple o stringhe, fino a te.
  • La mano e il campo di gioco possono essere matrici o stringhe delimitate.
• L'output deve essere di due indici dall'elenco delle mani che ho fornito (EG [2,1]).
  • Può essere restituito come parte di una funzione, stampato su console o output in modo adeguato.
  • Ci devono essere due valori distinti, uno per la tua mano migliore, un altro per la migliore possibile.
• 10 può essere rappresentato come To come 10, a seconda di quale senso abbia per te.
• Le scappatoie standard non sono ammesse.

Criteri vincenti

• Si tratta di code-golf , il conteggio di byte più basso con un pareggio della data di pubblicazione.

Haskell , 433 430 425 byte

-5 byte grazie a @Laikoni

import Data.List
q="23456789TJQKA"
e=elem
l=length
b=map
r p|z,elem 'A'u,elem 'K'u=1|z=2|e 4t=3|v<3=4|w=5|y=6|e 3t=7|v<4=8|v<5=9|1>0=10where u=[n!!0|n<-p];v=l$nub u;t=b(\n->l[x |x<-u,x==n])q;w=all(==(last$p!!0))[last s|s<-p];y=elem""[u\\s|s<-b(take 5.flip drop('A':q))[0..10]];z=y&&w
0%_=[[]]
n%(x:y)=b(x:)((n-1)%y)++n%y
_%_=[]
h#t|let p=h++t;c i=minimum$b r$concat$b(5%)$b(++i)((7-l i)%([n:[s]|n<-q,s<-"SCHD"]\\p))=(c p,c t)

Provalo online!

Ungolfed (stessa idea, struttura leggermente diversa):

import Data.List -- for (\\)
numbers = "23456789TJQKA"

e=elem

rank_hand hand
    |royal_flush=1
    |straight_flush=2
    |four_of_a_kind=3
    |full_house=4
    |flush=5
    |straight=6
    |three_kind=7
    |two_pair=8
    |pair=9
    |1>0=10
    where nums = [head n | n<-hand]
          unique = length $ nub nums
          counts = map (\n->length [x | x<-nums, x==n]) numbers
          pair = unique < 5
          two_pair = unique < 4 -- could also be 3 of a kind, but that's ok
          three_kind = e 3 counts
          flush = all (==(last$hand!!0)) [last s|s<-hand]
          straight = elem "" [nums\\s | s <- map (take 5.flip drop ('A':numbers))[0..10]]
          full_house = unique < 3
          four_of_a_kind = e 4 counts
          straight_flush = straight && flush
          royal_flush = straight_flush && elem 'A' nums && elem 'K' nums

-- taken from /codegolf//a/34496/66460
-- k%l finds combinations of size k from a list l
0%_=[[]]
n%(x:y)=map(x:)((n-1)%y)++n%y
_%_=[]

-- find every combination available to each player, and rank each one. 
-- could be golfed a lot more.
h#t=let p=h++t
        a=[n:[s]|n<-numbers,s<-"SCHD"]\\p
        c i=minimum $ map rank_hand $ concat $ map (5%) $ map (++i) ((7-length i)%a)
    in(c p,c t)

Molto lento, dato che non esiste alcun involucro speciale (ad es. Se non sono state mostrate carte, è sempre possibile una scala reale.) La maggior parte del mio impegno nel golf è entrato in rank_handfunzione; #può essere giocato a golf molto di più combinando mappe e simili.

hand#tablecalcola i punteggi ottimali per te e il tuo avversario. Non verifica errori.