7 Card Poker Evaluator main

Question

quelqu'un ne sait un algorithme rapide pour évaluer 7 mains de poker de cartes? Quelque chose qui est plus efficace que la simple force brute contrôle d'une tous les 21 combinaison de 5 cartes des mains d'un ensemble de 7.

Cheers,

Pete

Answer 1

Cette liste de site bouquet de Poker bibliothèques main et donne Evaluator quelques détails sur chacun d'entre eux. La plupart d'entre eux sont pour 5 mains de cartes, mais il y a au moins un pour une main de 7 cartes appelé Le Snezee7 Evaluator. De plus le site donne un aperçu des différentes techniques et algorithmes utilisés pour analyser rapidement les mains de poker.

Je l'ai utilisé Keith C # Règle Port du PokerSource Evaluator dans quelques différents projets de poker et pensent qu'il est une excellente bibliothèque. Il y a beaucoup de trucs intelligents que vous pouvez utiliser pour faire des évaluateurs main vraiment rapide, mais l'écriture du code est beaucoup de travail et je suggère fortement l'utilisation d'une bibliothèque existante.

Answer 2

J'ai écrit un dans JavaScript . Les utilisations de la méthode de l'évaluation de base que les manipulations bit est donc extrêmement rapide. Avec cela à l'esprit, en regardant 21 combinaisons est toujours très rapide. Le seul moment où nous devons aller plus loin est quand il y a égalité. Lorsque cela se produit, nous devons examiner plus de détails voir la carte dont 5 la main est en fait le meilleur. Voici la solution que je suis venu avec:

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],  [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ] ); 

Explication
Démo

Answer 3

Bonne question :) Oui, voici une toute nouvelle solution qui peut être juste le billet:

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

Une évolution de qualité commerciale de cet évaluateur est disponible pour l'iPhone / iPod Touch via iTunes Store. Il est appelé " Poker Ace ".

Un excellent résumé des différentes solutions complètes avec des liens se trouve sur le blog de James Devlin « Le codage roue ».

Un évaluateur pas encore discuté il y a Klaatu de .

Bonne chance!

Answer 4

I a développé un algorithme d'évaluation de la main de 7 cartes sans itérer les 21 combinaisons.

En gros, il divise la main de 7 cartes en deux catégories: chasse d'eau et non une chasse d'eau. Si c'est une chasse d'eau, il serait facile de rechercher la valeur dans un tableau de 8192 entrées. Si ce n'est pas une chasse d'eau, il va exécuter une fonction de hachage avec des techniques de programmation dynamique, puis rechercher la valeur dans une table de hachage de 49205 entrées.

Si vous êtes intéressé, s'il vous plaît vérifier mon travail à github.

https://github.com/HenryRLee/PokerHandEvaluator

Answer 5

J'ai créé un banc d'essai pour les évaluateurs de poker en C . Parmi les évaluateurs que j'ai testé, la bibliothèque de poker-eval a été le gagnant. Showdown Holdem Steve Brecher était aussi très rapide et a beaucoup moins de besoins en mémoire. Mon propre ACE_Eval a tenu son propre.

Je l'aide bienvenue d'ajouter d'autres évaluateurs, et les contributions des résultats des tests d'autres machines.

Answer 6

Je pense que vous devriez faire les 21 combinaisons et utiliser une sorte de tableau 7462. 1er: les 7 cartes ont 21 différentes cartes 5 combinaisons 2ème: toutes les mains possibles de poker finales (2.598.960) représente l'un des 7462 différents types de mains donc, d'une manière facile.

Vous avez juste à regarder toutes les 21 combinaisons de vos cartes et, pour chacun d'eux, voir le classement de 7462 tableau de classement. http://www.sendspace.com/file/pet0dd

Ensuite, pour chaque 7 cartes, vous aurez 21 différents classements de ce tableau 7462 je l'ai fait. Le plus haut gradé de 21 combinaisons est celui que vous voulez savoir.

Pour comprendre le tableau: Dans chaque ligne que vous avez la main de 5 cartes (Z pour adapté, Y non adapté) et vous avez le classement de celui-ci. Thats que vous avez besoin. Je vous donne la table et un algorithme d'exemple. ESt pas vraiment le code. Format de base d'une manière visuelle et je l'ai écrit maintenant. probablement doesnt travail, mais vous devez comprendre. Le code serait quelque chose comme 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 myranking. Vous devez connaître votre main en moins d'une seconde. Et est également bon de comparer avec d'autres mains, parce que vous avez la valeur de classement pas le nom de celui-ci. Et si vous voulez faire quelque chose avec des algorithmes de poker, c'est là que vous devriez commencer. Avec des valeurs de classement tout est rapide et facile.

Remarque: je ne suis pas un programmeur. Je suis veux être. Je comprends certaines fonctions de base visuels. Je Whish je savais comment faire des programmes réels. Si les travaux de l'algorithme, s'il vous plaît laisser un commentaire. Si vous voulez qu'il soit très très rapide, je sais comment ne pas le faire. Je whish j'ai un algorithme ultra rapide qui me permet vérifier (en temps réel) mes odds contre des adversaires à chaque étape du jeu. J'ai essayé plusieurs algorithmes pour calculer mes chances au flop en temps réel, mais le plus rapide que je peux 30 secondes. Maintenant, je peux calculer mes chances au flop en 3 secondes, mais j'utiliser une base de données de 150 giga-octets avec beaucoup de choses précalculée. Si vous voulez connaître vos chances en temps réel, vous devriez avoir beaucoup de choses précalculée. Thats comment je l'ai fait.

Answer 7

Bien sûr, si vous voulez le faire très vite. L'algorithme mis i avant est trop lent.

Le table7462 shoul être dans un tableau, pas dans un fichier.

Ensuite, vous devez précalculer toutes les différentes mains 7cards et le stocker dans une base de données. Il y a 133.784.560 différentes combinaisons de 7cards.

Vous devez utiliser ce format (Alphabetical ordre):

"2c2d2h2s3c3d3h" et le rang il

sauvons chaque 133.784.560 combinaisons différentes. Vous faites 52C7 cicles, le rang et le stocker dans une base de données. Peut-être dans quelques jours, vous avez prêt. Lorsque vous l'avez prêt, vous ne pas besoin de 21 combinaisons plus, il suffit de mettre la main triée par ordre alphabétique et recherchez dans votre base de données.

Si vous faites cela, voir que vous vous en aurez peut calculer vos chances contre vos adversaires en temps réel à chaque fois que vous avez besoin.

Croyez-moi. Je ne suis pas un programmeur et je peux le faire. Je sais que mes chances au flop en 3 secondes.

Answer 8

J'ai développé un simulateur Texas hold'em et au cours de ce développement, je trouve le nombre de 7462 combinaisons uniques (52 - 5/5) cartes sur le flop. À son tour, ce chiffre tombe à 6075 (5/6) et dans la rivière à 4824 (5/7). En effet, 1 ou 2 cartes ne sont pas pertinents pour classer la main de poker. Un exemple est le suivant: 76543QK = 7654332 une droite (3 à 7)

Mon simulateur est appelé Easy Poker et est disponible dans mon site http://crvltda.webs.com

Réf. Pokersoftware.com/forum

Answer 9

Mai je recommande https://github.com/chenosaurus/poker-evaluator/

Il est écrit en JavaScript et utilise un fichier de 128 Mo HandRanks.dat.

Le code est seulement quelques lignes et très facile à port à une autre langue.