7 Card Poker mano Evaluator

Question

Qualcuno conosce un algoritmo veloce per valutare 7 carte di mani di poker? Qualcosa che è più efficiente di una semplice forza bruta il controllo di una ogni 21 5 carte combinazione di mani da un insieme di 7.

Saluti,

Pete

Answer 1

Questo sito elenca un mucchio di Poker Hand Evaluator e dà alcuni dettagli su ciascuno di essi. La maggior parte di loro sono per 5 mani di carte, ma c'è almeno una per una mano 7 carte chiamato Lo Snezee7 Evaluator . Inoltre il sito dà una grande panoramica delle diverse tecniche e algoritmi utilizzati per analizzare le mani di poker in fretta.

Ho usato il Keith Regola C # Porto del PokerSource Valutatore in pochi diverso progetti di poker e pensare che si tratta di una libreria eccellente. Ci sono molti trucchi intelligenti che si possono usare per fare i valutatori mano veramente veloce, ma la scrittura del codice è un sacco di lavoro e vivamente suggerirei di usare una libreria esistente.

Answer 2

ho scritto uno in JavaScript . Gli usi metodo del nucleo valutare solo bit manipolazioni quindi è estremamente veloce. Con questo in mente, guardando a 21 combinazioni è ancora molto veloce. L'unica volta che abbiamo bisogno di andare più in profondità è quando si verifica un pareggio. Quando questo accade, abbiamo bisogno di guardare in maggiori dettagli per vedere quali 5 carte è in realtà il migliore. Ecco la soluzione mi è venuta:

hands=["4 of a Kind", "Straight Flush", "Straight", "Flush", "High Card",
       "1 Pair", "2 Pair", "Royal Flush", "3 of a Kind", "Full House" ];
var A=14, K=13, Q=12, J=11, _ = { "♠":1, "♣":2, "♥":4, "♦":8 };

//Calculates the Rank of a 5 card Poker hand using bit manipulations.
function rankPokerHand(cs,ss) {
  var v, i, o, s = 1<<cs[0]|1<<cs[1]|1<<cs[2]|1<<cs[3]|1<<cs[4];
  for (i=-1, v=o=0; i<5; i++, o=Math.pow(2,cs[i]*4)) {v += o*((v/o&15)+1);}
  v = v % 15 - ((s/(s&-s) == 31) || (s == 0x403c) ? 3 : 1);
  v -= (ss[0] == (ss[1]|ss[2]|ss[3]|ss[4])) * ((s == 0x7c00) ? -5 : 1);

  document.write("Hand: "+hands[v]+((s == 0x403c)?" (Ace low)":"")+"<br/>");
}

//Royal Flush   
rankPokerHand( [ 10, J, Q, K, A],  [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ] ); 

Spiegazione Qui
demo qui

Answer 3

Sono contento che hai chiesto :) Sì, ecco una nuova soluzione di marchio che potrebbe essere solo il biglietto:

Codice: http://code.google.com/p/specialkpokereval/ < br> Blog: http: //specialk-coding.blogspot .com / 2010/04 / texas holdem--7-card-evaluator_23.html

Un'evoluzione di tipo commerciale di questo valutatore è disponibile per l'iPod Touch iPhone / tramite iTunes Store. Si intitola " Poker Ace ".

Un eccellente sommario delle varie soluzioni complete con link si trova sul blog di James Devlin " Coding Il Wheel".

Un perito non ancora discussa c'è di Klaatu .

In bocca al lupo!

Answer 4

I ha sviluppato un algoritmo per la valutazione della mano 7-carta senza iterazione tutte le 21 combinazioni.

In sostanza, si divide la mano 7 carte in due categorie: a filo e non un filo. Se si tratta di un colore, sarebbe facile per cercare il valore in una tabella di 8192 voci. Se non è un colore, sarà eseguito una funzione di hash con tecniche di programmazione dinamica, e quindi cercare il valore in una tabella hash di 49205 voci.

Se siete interessati, si prega di consultare il mio lavoro a github.

https://github.com/HenryRLee/PokerHandEvaluator

Answer 5

Ho creato un banco di prova per i valutatori di poker in C qui . Dei valutatori che ho provato, la biblioteca poker-eval è stato il vincitore. Hold'em Showdown Steve Brecher era anche abbastanza veloce e ha avuto molto meno i requisiti di memoria. La mia ACE_Eval tenne il proprio.

avrei aiutato il benvenuto l'aggiunta di altri valutatori, e il contributo dei risultati dei test da altre macchine.

Answer 6

Penso che si dovrebbe fare le 21 combinazioni e utilizzare una sorta di 7462 tavolo. 1 °: un periodo di 7 carte hanno 21 diverse combinazioni di 5 carte 2 °: ogni possibile mani di poker finali (2.598.960) rappresenta uno dei 7462 diversi tipi di mani così, vale la facile.

Basta guardare a ogni 21 combinazioni di tue carte e, per ciascuno di essi, vedere la classifica del 7462 tabella di classifica. http://www.sendspace.com/file/pet0dd

Poi, per ogni 7 carte si avrà 21 diverse classifiche di questo 7462 tavolo ho fatto. La classifica delle 21 combinazioni più alto è quello che si desidera sapere.

Per capire il tavolo: in ogni riga si ha la mano di 5 carte (Z per adatto, Y non adatto) e si ha la classifica di esso. Thats solo bisogno. Vi do la tavola e un algoritmo esempio. Non E'davvero il codice. E'formato di base visivo e ho scritto subito. probabilmente Indifferente lavoro, ma si dovrebbe capire. Il codice potrebbe essere qualcosa di simile:

'############### 1st: Define your hand, for example "2c2d2h2s3c3h3s" #############################################################################################

Dim mycard As New ArrayList

mycard(1).Add("2c")
mycard(2).Add("2d")
mycard(3).Add("2h")
mycard(4).Add("2s")
mycard(5).Add("3c")
mycard(6).Add("3h")
mycard(7).Add("3s")
mycard.Sort() '################# you need to sort in alphabeticall order to match it later with 7462 table #############################################



' ################## 2nd: Let´s transform it to every kind of 5 cards combinations (21). It will also preserve the alphabeticall order ##################################

Dim myHand5 As String = ""
Dim suited as String = ""
Dim ranking as Integer = 0
Dim myranking as Integer = 7462
Dim mystring as String = ""

For cicle1 = 0 to 2
     For cicle2 = cicle1 + 1 to 3
          For cicle3 = cicle3 + 1 to 4
               For cicle4 = cicle3 + 1 to 5
                    For cicle5 = cicle4 + 1 to 6
                         myhand5 = left(mycard(cicle1),1) & left(mycard(cicle2),1) & left(mycard(cicle3),1) & left(mycard(cicle4),1)  & left(mycard(cicle5),1)
                         suited = left(mycard(cicle1),2) & left(mycard(cicle2),2) & left(mycard(cicle3),2) & left(mycard(cicle4),2)  & left(mycard(cicle5),2)
                         if suited = "ccccc" or suited = "ddddd" or suited = "hhhhh" or suited = "sssss" then myhand5 = myhand5 & "Z" Else myhand5 = myhand5 & "Y"  
                          ranking = 0                              
                          FileOpen (1, "7462.txt", Input)
                          Do
                               ranking = ranking + 1
                               Input(1, mystring)
                               Input(1, ranking)
                               If mystring = myhand5 Then 
                                    If ranking < myranking then myrankin = ranking
                               End If
                          Loop Until EOF(1)
                          FileClose(1)
                    Next cicle5
               Next cicle4
          Next cicle3
     Next cicle2
Next cicle1

Graduatoria finale è myranking variabile. Si deve sapere la mano in meno di un secondo. Ed è anche un bene da confrontare con altre mani, perché si ha il valore di classifica non il nome di essa. E se si vuole fare qualcosa con algoritmi di poker, questo è dove si dovrebbe iniziare. Con valori di classifica tutto è semplice e veloce.

Nota: io non sono un programmatore. Sono un Wanna Be. Capisco alcune funzioni di base visivi. I Whish sapevo come fare i programmi veri e propri. Se funziona l'algoritmo, si prega di lasciare un commento. Se si vuole che sia molto molto veloce, Io non so come farlo. Ho whish ho un algoritmo veloce ultra che mi permette controllare (in tempo reale) le mie probabilità contro eventuali avversari in ogni fase del gioco. Ho provato molti algoritmi per calcolare le mie probabilita 'al flop in tempo reale, ma il più veloce che posso è di 30 secondi. Ora, posso calcolare le probabilità al flop in 3 secondi, ma io uso un database di 150 gigabyte con molte cose precalcolati. Se volete sapere le vostre probabilità in tempo reale si dovrebbe avere molte cose precalcolati. Thats come ho fatto.

Answer 7

Naturalmente, se si vuole farlo molto velocemente. L'algoritmo ho messo prima è troppo lento.

Il table7462 shoul essere in una matrice, non in un file.

Quindi, si dovrebbe precalculate ogni 7cards mani diverse e conservarlo in un database. Ci sono diverse 133.784.560 7cards combinazioni.

Si dovrebbe utilizzare questo formato (Alphabeticall ordine):

"2c2d2h2s3c3d3h" e il rango che

negozio ogni 133.784.560 combinazioni diverse. Tu fai 52C7 cicli, rango e conservarla in un database. Forse in pochi giorni lo avete pronto. Quando hai pronto, si Non tiratevi bisogno di 21 combinazioni di più, basta mettere la mano in ordine alfabetico e cercare nel database.

Se lo fai, Vedrai che è possibile calcolare le vostre probabilità contro i tuoi avversari in tempo reale ogni volta che è necessario.

Mi creda. Io non sono un programmatore e posso farlo. So che le mie probabilita 'al flop in 3 secondi.

Answer 8

Ho sviluppato un simulatore di Texas Hold'em e nel corso di questo sviluppo ho trovato il numero di 7462 combinazioni uniche (52 - 5/5 carte) al flop. A sua volta, questo numero scende a 6075 (5/6) e nel fiume per 4824 (5/7). Questo perché 1 o 2 carte sono irrilevanti nel classificare la mano di poker. Un esempio è il seguente: 76543QK = 7.654.332 una scala (da 3 a 7)

Il mio simulatore si chiama Facile Poker ed è disponibile nel mio sito http://crvltda.webs.com

Ref. Pokersoftware.com/forum

Answer 9

https://github.com/chenosaurus/poker-evaluator/

E 'scritto in JavaScript e utilizza un file di 128 MB HandRanks.dat.

Il codice è solo poche righe e molto facile da porta a qualsiasi altra lingua.