Qualcuno conosce un algoritmo veloce per la valutazione delle mani di 7 carte da 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.7 Card Poker Hand Evaluator
Cheers,
Pete
Questo sito elenca una serie di Poker Hand Evaluator libraries e dà alcuni dettagli su ciascuno di essi. Molti di questi sono per 5 mani di carte, ma ce n'è almeno una per una mano di 7 carte chiamata The Snezee7 Evaluator. Inoltre, il sito offre una grande panoramica delle diverse tecniche e algoritmi utilizzati per analizzare rapidamente le mani di poker.
Ho usato la porta Keith Rule C# del Pokersource Evaluator in un numero diverso poker projects e penso che sia una libreria eccellente. Ci sono molti trucchi intelligenti che puoi usare per fare valutatori di mani davvero veloci, ma scrivere il codice è molto lavoro e ti consiglio caldamente di usare una libreria esistente.
Nota che Snezee7 richiede una tabella di ricerca 266 MB. –
Lo fa ... ma è così che ottieni un valutatore di mano veloce (un sacco di pre-computazione). Il valutatore Two Plus Two utilizza un approccio simile per valutare 7 mani di carte utilizzando una tabella di ricerca 123 MB. Per 5 mani di carte le tabelle di ricerca sono molto più piccole. –
plug spudorato - Anche se non veloce come alcuni di quelli sopra, ne ho uno che fa ~ 70M mani/s senza usare tabelle qui: https://github.com/ashelly/ACE_eval. – AShelly
contento che hai chiesto :) Sì, ecco una soluzione nuova di zecca che potrebbe essere solo il biglietto:
Codice: http://code.google.com/p/specialkpokereval/
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'iPhone/iPod Touch tramite iTunes Store. Si chiama "Poker Ace".
Un eccellente sommario di varie soluzioni complete di collegamenti si trova sul blog di James Devlin "Coding The Wheel".
Un valutatore non ancora discusso è Klaatu's.
Buona fortuna!
Ho aggiunto il tuo valutatore alla mia [retata] (https://github.com/ashelly/pet). Apprezzerei qualsiasi feedback. – AShelly
Ho scritto uno su JavaScript. Il metodo di valutazione principale utilizza solo manipolazioni di bit, quindi è estremamente veloce. Con questo in mente, osservare 21 combinazioni è ancora molto veloce. L'unica volta che dobbiamo approfondire è quando si verifica un pareggio. Quando ciò accade, dobbiamo esaminare più dettagli per vedere quale mano con 5 carte è effettivamente la 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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ]);
un sacco di sforzo messo in questo! +1 :) –
È una strega! Articolo fantastico. –
C'è un bug in questo codice - se hai una scala con un asso come carta bassa (ad esempio A ♣ 2 ♦ 3 ♦ 4 ♠ 5 ♥ 6 ♦ K ♥), seleziona in modo errato la scala * inferiore *. In questo esempio il 6 ♦ dritto in alto dovrebbe essere il migliore. Questo perché sta dando più peso all'Asso ma in questo caso è sbagliato farlo non essendo il rettilineo alto ma piuttosto il rettilineo inferiore. vedi https://imgur.com/a/e9wGR – wal
Penso che si dovrebbe fare le 21 combinazioni e utilizzare una sorta di 7462 tavolo. 1 °: qualsiasi 7 carte hanno 21 combinazioni di 5 carte diverse 2 °: ogni possibile mano di poker finale (2.598.960) rappresenta uno dei 7462 diversi tipi di mani quindi, è facile.
Devi solo guardare ogni 21 combinazioni delle tue carte e, per ognuna, vedere la classifica della tabella di classifica 7462. http://www.sendspace.com/file/pet0dd
Quindi, per ogni 7 carte si avranno 21 diverse classifiche da questo tavolo 7462 creato. La classifica più alta di 21 combinazioni è quella che vuoi sapere.
Per capire la tabella: In ogni riga hai la mano di 5 carte (Z per suited, Y non adatto) e ne hai la classifica. Questo è solo il tuo bisogno. Ti do la tabella e un algoritmo di esempio. Non è davvero il codice.È il formato di base visivo e l'ho scritto ora. probabilmente non funziona, ma dovresti capire. Il codice dovrebbe essere qualcosa del tipo:
'############### 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
La classifica finale è variabile myranking. Dovresti conoscere la tua mano in meno di un secondo. Ed è anche buono da confrontare con le altre mani, perché hai il valore di classifica e non il nome di esso. E se vuoi fare qualcosa con gli algoritmi del poker, è qui che dovresti iniziare. Con i valori di classifica tutto è semplice e veloce.
Nota: non sono un programmatore. Io voglio essere. Comprendo alcune funzioni di base visive. Sapevo come fare programmi reali. Se l'algoritmo funziona, si prega di lasciare un commento. Se vuoi che sia molto veloce, non so come farlo. Desidero avere un algoritmo ultra veloce che mi permette di controllare (in tempo reale) le mie probabilità contro qualsiasi avversario in ogni fase del gioco. Ho provato molti algoritmi per calcolare le mie probabilità al flop in tempo reale ma il più veloce che posso è di 30 secondi. Ora, posso calcolare le mie probabilità al flop in 3 secondi ma uso un database da 150 gigabyte con molte cose precalcolate. Se vuoi conoscere le tue quote in tempo reale, dovresti avere molte cose precalcolate. Ecco come ho fatto.
Naturalmente, se si vuole farlo molto velocemente. L'algoritmo che ho messo prima è troppo lento.
Il table7462 deve essere in una matrice, non in un file.
Quindi, è necessario calcolare preliminarmente tutte le 7 mani di diverse carte e memorizzarle in un database. Ci sono 133.784.560 diverse combinazioni di 7 carte.
Si dovrebbe utilizzare questo formato (Alphabeticall ordine):
"2c2d2h2s3c3d3h" e rango
negozio ogni 133.784.560 combinazioni diverse. Fai 52 cicli ciclici, posizionali e memorizzali in un database. Forse in pochi giorni lo hai pronto. Quando lo hai pronto, non hai più bisogno di 21 combinazioni, metti la tua mano in ordine alfabetico e cercalo nel tuo database.
Se lo fai, vedrai che puoi calcolare le quote contro i tuoi avversari in tempo reale ogni volta che ne hai bisogno.
Credimi. Non sono un programmatore e posso farlo. Conosco le mie probabilità al flop in 3 secondi.
Ho sviluppato un simulatore Texas Hold'em e durante questo sviluppo ho trovato il numero di 7462 combinazioni uniche (52 - 5/5 carte) sul flop. A sua volta, questo numero scende a 6075 (5/6) e nel fiume a 4824 (5/7). Questo perché 1 o 2 carte sono irrilevanti nel classificare la mano di poker. Un esempio è: 76543QK = 7.654.332 un dritto (3-7)
mio simulatore si chiama Facile Poker ed è disponibile nel mio sito http://crvltda.webs.com
Ref. Pokersoftware.com/forum
Ho creato un banco di prova per valutatori di poker in C here. Tra i valutatori che ho provato, la libreria poker-eval è stata la vincitrice. Steve Brecher's Holdem Showdown era anche abbastanza veloce e aveva un fabbisogno di memoria significativamente inferiore. Il mio ACE_Eval ha tenuto il suo.
Sarei felice di aiutare ad aggiungere altri valutatori e contributi dei risultati dei test di altre macchine.
Ho dato una buona occhiata al valutatore di Steve Brecher, ma sto facendo fatica a estrarre i valori delle carte dal suo risultato di valutazione 0x0V0RRRRR. Puoi aggiungere un decodificatore più dettagliato nella sezione BHS dei tuoi benchmark? – JSON
Cercherò di arrivare a questo, ma nel frattempo: ci sono fino a 5 "R" nibbles, dove '0'..'C' rappresenta '2' .. 'Ace'. Rappresentano i valori delle carte che compongono il rango della mano. I '0' finali vengono ignorati. È necessario controllare il rango per determinare quanti valori estrarre. Quindi per 4 assi con un kicker 7 avresti 'C5000'. Per i re di Full House over 3, ottieni 'B1000'. Two Pair, 8s e 4s con un kicker Queen è '62A00'. E così via. Una mano con carta alta userebbe tutti i 5 stuzzichini. ACE_Eval.h usa una rappresentazione simile. Vedi 'ACE_decode()' per un modo per ottenere le carte vincenti. – AShelly
Ho sviluppato un algoritmo per la valutazione della mano a 7 carte senza iterare tutte le 21 combinazioni.
Fondamentalmente, divide la mano di 7 carte in due categorie: a filo e non a filo. Se è un colore, sarebbe facile cercare il valore in una tabella di 8192 voci. Se non è un flush, eseguirà una funzione di hash con tecniche di programmazione dinamica, quindi cercherà il valore in una tabella hash di 49205 voci.
Se sei interessato, controlla il mio lavoro su github.
Bella domanda, ma penso che è meglio solo controllando le 21 combinazioni invece di cercare di capire un po 'espediente pazzo a scelta rapida. –
@David In realtà, nulla potrebbe essere più lontano dalla verità. Le persone hanno fatto un sacco di sforzi per scrivere velocemente 7 valutatori di carte. Quando vuoi fare milioni di mani al secondo, la velocità diventa importante. –
@David: Ci sono modi migliori che sono più facili da leggere e richiedono NESSUN ordinamento. Sono anche diversi ordini di grandezza più veloci per questo. Un esempio è - ahem - trovato qui: http://code.google.com/p/specialkpokereval/. – SK9