Kennt jemand einen schnellen Algorithmus zur Bewertung von 7 Karten Poker Händen? Etwas, was viel effizienter als ein Brute-Force ist eine jede 21 5-Karten-Kombination aus den Händen von einem Satz von 77 Card Poker Hand Evaluator
Prost Überprüfung
Pete
Diese Seite listet eine Reihe von Poker Hand Evaluator libraries und gibt ein paar Details über jeden von ihnen. Die meisten von ihnen sind für 5 Karten Hände, aber es gibt mindestens eine für eine 7-Karten Hand namens The Snezee7 Evaluator. Außerdem gibt die Seite einen guten Überblick über die verschiedenen Techniken und Algorithmen, mit denen Pokerhände schnell analysiert werden können.
Ich habe die Keith Regel C# Port der Pokersource Evaluator in ein paar verschiedene poker projects und denke, dass es eine ausgezeichnete Bibliothek ist. Es gibt viele clevere Tricks, die Sie verwenden können, um wirklich schnelle Handauswerter zu erstellen, aber das Schreiben des Codes ist eine Menge Arbeit und ich würde sehr empfehlen, eine vorhandene Bibliothek zu verwenden.
Beachten Sie, dass Snezee7 eine Nachschlagetabelle mit 266 MB benötigt. –
Es tut ... aber das ist, wie Sie einen schnellen Hand-Evaluator bekommen (viel Vorberechnung). Der Two-Plus-Two-Evaluator verwendet einen ähnlichen Ansatz zum Auswerten von 7 Kartenhänden unter Verwendung einer 123-MB-Nachschlagetabelle. Für 5 Kartenhände sind die Nachschlagetabellen viel kleiner. –
schamloser Stecker - Obwohl nicht so schnell wie einige der oben genannten, habe ich eine, die ~ 70M Hände/s verwendet keine Tabellen hier: https://github.com/ashelly/ACE_eval. – AShelly
Gut, dass Sie gefragt :) Ja, hier ist eine neue Marke Lösung, die genau das Richtige sein kann:
Code: http://code.google.com/p/specialkpokereval/
Blog: http://specialk-coding.blogspot.com/2010/04/texas-holdem-7-card-evaluator_23.html
Eine handelsüblichem Entwicklung dieses Bewerters ist für das iPhone/iPod Touch über den iTunes Store. Es heißt "Poker Ace".
Eine exzellente Zusammenfassung verschiedener Lösungen mit Links findet sich auf James Devlins Blog "Coding The Wheel".
Ein noch nicht besprochener Bewerter ist Klaatu's.
Viel Glück!
Ich habe Ihren Bewerter zu meiner [Zusammenfassung] hinzugefügt (https://github.com/ahelly/pet). Ich würde mich über jede Rückmeldung freuen. – AShelly
Ich schrieb eine in JavaScript. Das Kernauswertungsverfahren verwendet nur Bitmanipulationen und ist daher extrem schnell. Vor diesem Hintergrund ist die Betrachtung von 21 Kombinationen immer noch sehr schnell. Die einzige Zeit, in der wir tiefer gehen müssen, ist, wenn ein Gleichstand auftritt. Wenn dies passiert, müssen wir genauer hinsehen, um zu sehen, welche Hand mit 5 Karten tatsächlich die beste ist. Hier ist die Lösung, die ich kam mit:
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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ]);
viel Aufwand in diesem einen! +1 :) –
Er ist eine Hexe! Super Artikel. –
Es gibt einen Fehler in diesem Code - wenn Sie eine Straight mit einem Ass als Low-Karte haben (z. B. A ♣ 2 ♦ 3 ♦ 4 ♠ 5 ♥ 6 ♦ K ♥), wählt sie fälschlicherweise die * niedrigere * Straight. In diesem Beispiel sollte die 6 ♦ hohe Gerade am besten sein. Dies ist, weil es dem Ass ein zusätzliches Gewicht verleiht, aber in diesem Fall ist es falsch, dies zu tun, da es nicht die hohe Gerade, sondern die untere Gerade ist. siehe https://imgur.com/a/e9wGR – wal
Ich glaube, Sie sollten die 21 Kombinationen tun und eine Art von 7462 Tabelle verwenden. 1: alle 7 Karten haben 21 verschiedene 5 Karten Kombinationen 2: jede mögliche letzte Poker Hände (2.598.960) stellt eine von 7462 verschiedenen Arten von Händen so, es ist einfach.
Sie müssen nur alle 21 Kombinationen Ihrer Karten betrachten und für jede einzelne die Rangliste der 7462 Rangliste sehen. http://www.sendspace.com/file/pet0dd
Dann, für jede 7 Karten haben Sie 21 verschiedene Platzierungen von dieser 7462 Tabelle, die ich gemacht habe. Die höchste Bewertung von 21 Kombinationen ist diejenige, die Sie wissen möchten.
Um die Tabelle zu verstehen: In jeder Zeile haben Sie die 5-Karten-Hand (Z für suited, Y nicht-suited) und Sie haben das Ranking davon. Das brauchst du nur. Ich gebe Ihnen die Tabelle und einen Beispielalgorithmus. Es ist nicht wirklich der Code.Es ist ein visuelles Basisformat und ich habe es jetzt geschrieben. funktioniert wahrscheinlich nicht, aber du solltest es verstehen. Der Code würde in etwa so aussehen:
'############### 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
Endgültiges Ranking ist Myranking Variable. Du solltest deine Hand in weniger als einer Sekunde kennen. Und es ist auch gut, mit anderen Händen zu vergleichen, weil Sie den Ranking-Wert nicht den Namen haben. Und wenn Sie etwas mit Poker-Algorithmen machen wollen, sollten Sie hier anfangen. Mit Rankingwerten ist alles schnell und einfach.
Hinweis: Ich bin kein Programmierer. Ich bin ein Möchtegern. Ich verstehe einige visuelle Grundfunktionen. Ich wünschte ich könnte echte Programme machen. Wenn der Algorithmus funktioniert, hinterlassen Sie bitte einen Kommentar. Wenn Sie wollen, dass es sehr, sehr schnell ist, weiß ich nicht, wie es geht. Ich wünschte, ich hätte einen ultraschnellen Algorithmus, der es mir erlaubt, in Echtzeit (in Echtzeit) meine Chancen gegen Gegner in jeder Phase des Spiels zu überprüfen. Ich habe viele Algorithmen ausprobiert, um meine Chancen am Flop in Echtzeit zu berechnen, aber das schnellste ist 30 Sekunden. Jetzt kann ich meine Chancen am Flop in 3 Sekunden berechnen, aber ich benutze eine 150-Gigabyte-Datenbank mit vielen vorberechneten Dingen. Wenn Sie Ihre Chancen in Echtzeit wissen möchten, sollten Sie viele Dinge vorausberechnet haben. So habe ich es gemacht.
Natürlich, wenn Sie es sehr schnell machen wollen. Der Algorithmus, den ich vorstelle, ist zu langsam.
Die Tabelle7462 sollte sich in einem Array befinden, nicht in einer Datei.
Dann sollten Sie alle 7cards Hände vorberechnen und in einer Datenbank speichern. Es gibt 133.784.560 verschiedene 7cards Kombinationen.
sollten Sie dieses Format verwenden (alphabeticall Reihenfolge):
"2c2d2h2s3c3d3h" und es
Shop alle 133.784.560 verschiedene Kombinationen Ringen. Sie machen 52C7 Cicles, ordnen sie ein und speichern sie in einer Datenbank. Vielleicht hast du es in ein paar Tagen fertig. Wenn Sie es fertig haben, brauchen Sie keine 21 Kombinationen mehr, legen Sie einfach Ihre Hand alphabetisch sortiert und suchen Sie in Ihrer Datenbank danach.
Wenn Sie das tun, werden Sie sehen, dass Sie Ihre Chancen gegen Ihre Gegner in Echtzeit berechnen können, wann immer Sie brauchen.
Glauben Sie mir. Ich bin kein Programmierer und ich kann es tun. Ich kenne meine Chancen am Flop in 3 Sekunden.
Ich entwickelte einen Texas Hold'em Simulator und während dieser Entwicklung fand ich die Anzahl von 7462 einzigartigen Kombinationen (52 - 5/5 Karten) auf dem Flop. Diese Zahl sinkt wiederum auf 6075 (5/6) und im Fluss auf 4824 (5/7). Dies liegt daran, dass 1 oder 2 Karten beim Klassifizieren der Pokerhand irrelevant sind. Ein Beispiel ist: 76543QK = 7654332 ein gerade (3 bis 7)
Mein Simulator Einfaches Poker genannt wird und in meiner Website http://crvltda.webs.com
Ref zur Verfügung steht. Pokersoftware.com/forum
Ich habe ein Testbett für Poker-Evaluatoren in C here erstellt. Von den Evaluatoren, die ich getestet habe, war die poker-eval Bibliothek der Gewinner. Steve Brecher's Holdem Showdown war auch ziemlich schnell und hatte deutlich weniger Speicherbedarf. Meine eigene ACE_Eval hielt es für sich.
Ich würde gerne helfen, andere Bewerter und Beiträge von Testergebnissen von anderen Maschinen hinzuzufügen.
Ich hatte einen guten Blick auf Steve Brechers Evaluator, aber es fällt mir schwer, Kartenwerte aus seinem 0x0V0RRRRR-Auswertungsergebnis zu extrahieren. Können Sie einen detaillierteren Decoder im BHS-Bereich Ihrer Benchmarks hinzufügen? – JSON
Ich werde versuchen, dazu zu kommen, aber in der Zwischenzeit: Es gibt bis zu 5 'R' Halbbytes, wobei '0'..'C 'für' 2 'steht.' Ace '. Sie repräsentieren die Werte der Karten, aus denen der Handrang besteht. Trailing '0's werden ignoriert. Sie müssen sich den Rang ansehen, um zu bestimmen, wie viele Werte ausgegeben werden sollen. Also für 4 Aces mit einem 7 Kicker würde man 'C5000' haben. Für Full House Kings über 3s erhalten Sie 'B1000'. Zwei Paare, 8er und 4er mit einem Queen-Kicker ist '62A00'. Und so weiter. Eine High-Card-Hand würde alle 5 Nibbles verwenden. ACE_Eval.h verwendet eine ähnliche Darstellung. Siehe 'ACE_decode()' für eine Möglichkeit, die Gewinnkarten zu erhalten. – AShelly
Ich entwickelte einen Algorithmus für die 7-Karten-Handauswertung, ohne alle 21 Kombinationen zu durchlaufen.
Grundsätzlich teilt es die 7-Karten Hand in zwei Kategorien: Flush und nicht Flush. Wenn es sich um einen Flush handelt, wäre es einfach, den Wert in einer Tabelle mit 8192 Einträgen nachzuschlagen. Wenn es kein Flush ist, wird eine Hash-Funktion mit Techniken der dynamischen Programmierung ausgeführt, und dann wird der Wert in einer Hash-Tabelle mit 49205 Einträgen nachgeschlagen.
Wenn Sie interessiert sind, überprüfen Sie bitte meine Arbeit bei Github.
Gute Frage, aber ich glaube, du bist besser dran, nur die 21 Kombinationen Überprüfung anstatt zu versuchen, ein paar verrückte Spielerei, um herauszufinden, abzukürzen. –
@David Eigentlich könnte nichts weiter von der Wahrheit entfernt sein. Die Leute haben sich viel Mühe gegeben, schnelle 7-Karten-Evaluatoren zu schreiben. Wenn Sie Millionen von Händen pro Sekunde machen wollen, wird Geschwindigkeit wichtig. –
@David: Es gibt viel bessere Möglichkeiten, die einfacher zu lesen sind und KEINE Sortierung erfordern. Sie sind auch mehrere Größenordnungen schneller dafür. Ein Beispiel ist - ähem - hier zu finden: http://code.google.com/p/specialkpokereval/. – SK9