Évaluateur de poker principal 7 cartes
Est-ce que quelqu'un connaît un algorithme rapide pour évaluer les mains de poker à 7 cartes? Quelque chose de plus efficace que la simple force brute qui consiste à vérifier une combinaison de mains sur 21 cartes parmi un jeu de 7.
À votre santé,
Pete
Ce site répertorie un groupe de bibliothèques de Poker Hand Evaluator et donne quelques détails sur chacun d’entre eux. La plupart d'entre eux sont destinés à des mains de 5 cartes, mais il en existe au moins une pour une main de 7 cartes appelée l'évaluateur de Snezee7 . De plus, le site donne un bon aperçu des différentes techniques et algorithmes utilisés pour analyser rapidement les mains de poker.
J'ai utilisé le port Keith Rule C # de Pokersource Evaluator dans plusieurs projets de poker et je considère que c'est une excellente bibliothèque. Il existe de nombreuses astuces astucieuses que vous pouvez utiliser pour réaliser des évaluateurs de main très rapides, mais écrire le code demande beaucoup de travail et je suggérerais fortement d'utiliser une bibliothèque existante.
J'en ai écrit un dans JavaScript . La méthode d'évaluation principale utilise uniquement des manipulations de bits et est donc extrêmement rapide. Dans cet esprit, examiner 21 combinaisons est encore très rapide. Le seul moment où nous devons aller plus loin, c'est quand une égalité se produit. Lorsque cela se produit, nous devons examiner plus de détails pour déterminer quelle main de 5 cartes est la meilleure. Voici la solution que j'ai trouvée:
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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ] );
Heureux que vous ayez demandé :) Oui, voici une toute nouvelle solution qui pourrait bien être le ticket:
Code: http://code.google.com/p/specialkpokereval/
Blog: http://specialk-coding.blogspot.com/2010/04/texas-holdem-7-card-evaluator_23.html
Une version commerciale de cet évaluateur est disponible pour l'iPhone/iPod Touch via iTunes Store. Cela s'appelle " Poker Ace ".
Vous trouverez un excellent résumé des différentes solutions complètes avec des liens sur le blog de James Devlin " Coding The Wheel ".
Un évaluateur qui n’a pas encore discuté est Klaatu's .
Bonne chance!
J'ai développé un algorithme pour l'évaluation manuelle à 7 cartes sans itérer les 21 combinaisons.
Fondamentalement, il divise la main de 7 cartes en deux catégories: une couleur et non une couleur. Si c'est une couleur, il serait facile de rechercher la valeur dans un tableau de 8192 entrées. Si ce n'est pas un flush, il exécutera une fonction de hachage avec des techniques de programmation dynamique, puis recherchera la valeur dans une table de hachage de 49205 entrées.
Si vous êtes intéressé, veuillez consulter mon travail sur github.
J'ai créé un banc d'essai pour les évaluateurs de poker dans C ici . Parmi les évaluateurs que j'ai testés, la bibliothèque poker-eval a été gagnante. Holdem Showdown de Steve Brecher était également assez rapide et avait considérablement moins de besoins en mémoire. Mon propre ACE_Eval a eu le sien.
Je serais heureux d’aider à ajouter d’autres évaluateurs et à contribuer aux résultats des tests d’autres machines.
Je pense que vous devriez faire les 21 combinaisons et utiliser une sorte de table 7462. 1ère: 7 cartes sur 21 ont 5 combinaisons de 5 cartes différentes 2e: toutes les mains de poker finales possibles (2.598.960) représentent l’une des 7462 sortes de mains Différentes. s facile.
Il vous suffit de regarder toutes les 21 combinaisons de vos cartes et, pour chacune d’elles, de voir le classement du classement de 7462. http://www.sendspace.com/file/pet0dd
Ensuite, pour chaque 7 cartes, vous aurez 21 classements différents de ce tableau 7462 que j’ai établi. Le classement le plus élevé parmi 21 combinaisons est celui que vous voulez connaître.
Pour comprendre le tableau: Dans chaque ligne, vous avez la main de 5 cartes (Z pour un assorti, Y non adapté) et vous avez le classement de celle-ci. Ce n'est que ce dont vous avez besoin. Je vous donne le tableau et un exemple d'algorithme. Ce n'est pas vraiment le code. C'est le format visuel de base et je l'ai écrit maintenant. ne fonctionne probablement pas, mais vous devez comprendre. Le code ressemblerait à ceci:
'############### 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
Le classement final est variable variable. Vous devriez connaître votre main en moins d'une seconde. Et il est également bon de comparer avec les autres mains, car vous avez la valeur de classement pas le nom de celle-ci. Et si vous voulez faire quelque chose avec les algorithmes de poker, vous devez commencer ici. Avec le classement des valeurs, tout est rapide et facile.
Note: Je ne suis pas un programmeur. Je suis un veux être. Je comprends certaines fonctions visuelles de base. Je souhaite savoir comment faire de vrais programmes. Si l'algorithme fonctionne, laissez un commentaire. Si vous voulez que ce soit très rapide, je ne sais pas comment le faire. Je souhaite avoir un algorithme ultra rapide qui me permet de vérifier (en temps réel) mes chances de contre tous les adversaires à chaque étape du jeu. J'ai essayé de nombreux algorithmes pour calculer mes cotes au flop en temps réel, mais le plus rapide que je puisse faire est de 30 secondes. Maintenant, je peux calculer mes chances au flop en 3 secondes mais j'utilise une base de données de 150 gigaoctets avec beaucoup de choses pré-calculées. Si vous voulez connaître vos chances en temps réel, vous devriez avoir beaucoup de choses pré-calculées. C'est comme ça que j'ai fait.
Puis-je recommander https://github.com/chenosaurus/poker-evaluator/
Il est écrit en JavaScript et utilise un fichier HandRanks.dat de 128 Mo.
Le code ne contient que quelques lignes et est très facile à transférer dans une autre langue.
J'ai développé un simulateur Texas Hold'em et au cours de ce développement, j'ai trouvé le nombre de 7462 combinaisons uniques (52 - 5/5 cartes) sur le flop. À son tour, ce nombre tombe à 6075 (5/6) et dans la rivière à 4824 (5/7). En effet, 1 ou 2 cartes ne sont pas pertinentes pour classer la main de poker. Un exemple est: 76543QK = 7654332 une suite (3 à 7)
Mon simulateur s'appelle Easy Poker et est disponible sur mon site http://crvltda.webs.com
Réf. Pokersoftware.com/forum