algorithm - palos - 7 Evaluador de manos de Poker de cartas
orden de las cartas de poker (9)
¿Alguien sabe un algoritmo rápido para evaluar 7 manos de póker de tarjeta? Algo que es más eficiente que la simple fuerza bruta verificando una combinación de 21 manos y 5 cartas de manos de un conjunto de 7.
Aclamaciones,
Pete
Creé un banco de pruebas para evaluadores de poker en C here . De los evaluadores que probé, la biblioteca de poker-eval fue la ganadora. El Holdem Showdown de Steve Brecher también fue bastante rápido y tenía requisitos de memoria significativamente menores. Mi propio ACE_Eval sostuvo.
Me gustaría recibir ayuda para agregar otros evaluadores y contribuciones de resultados de pruebas de otras máquinas.
Creo que deberías hacer las 21 combinaciones y usar algún tipo de tabla 7462. 1º: 7 cartas tienen 21 combinaciones diferentes de 5 cartas. 2º: todas las posibles manos finales de póker (2.598.960) representan uno de los 7462 tipos diferentes de manos, así que es fácil.
Solo tienes que mirar las 21 combinaciones de tus cartas y, para cada una, ver el ranking de la tabla de clasificación 7462. http://www.sendspace.com/file/pet0dd
Luego, por cada 7 cartas, tendrás 21 clasificaciones diferentes de esta tabla 7462 que hice. La clasificación más alta de 21 combinaciones es la que quieres saber.
Para entender la tabla: en cada línea tienes la mano de 5 cartas (Z para el adecuado, Y no es el adecuado) y tienes el ranking de la misma. Eso es lo único que necesitas. Te doy la tabla y un algoritmo de ejemplo. Realmente no es el código. Su formato visual básico y lo escribí ahora. probablemente no funcione pero deberías entender. El código sería algo como esto:
''############### 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 clasificación final es una variable de miranking. Debes conocer tu mano en menos de un segundo. Y también es bueno compararlo con otras manos, porque tiene el valor de clasificación no el nombre. Y si quiere hacer algo con los algoritmos de póker, aquí es donde debería comenzar. Con los valores de clasificación todo es rápido y fácil.
Nota: No soy un programador. Yo soy un ser querido. Entiendo algunas funciones visuales básicas. Quise saber cómo hacer programas reales. Si el algoritmo funciona, por favor deje un comentario. Si quieres que sea muy rápido, no sé cómo hacerlo. Quisiera tener un algoritmo ultrarrápido que me permita verificar (en tiempo real) mis probabilidades contra cualquier oponente en cada etapa del juego. Intenté muchos algoritmos para calcular mis probabilidades en el flop en tiempo real, pero lo más rápido que puedo es 30 segundos. Ahora puedo calcular mis probabilidades en el flop en 3 segundos, pero uso una base de datos de 150 gigabytes con muchas cosas precalculadas. Si desea conocer sus probabilidades en tiempo real, debe tener muchas cosas precalculadas. Así es como lo hice.
Desarrollé un algoritmo para la evaluación manual de 7 cartas sin iterar las 21 combinaciones.
Básicamente, divide la mano de 7 cartas en dos categorías: color y no color. Si es un color, sería fácil buscar el valor en una tabla de 8192 entradas. Si no es un color, ejecutará una función hash con técnicas de programación dinámica, y luego buscará el valor en una tabla hash de 49205 entradas.
Si estás interesado, por favor revisa mi trabajo en github.
Desarrollé un simulador Texas hold''em y durante este desarrollo encontré el número de 7462 combinaciones únicas (52 - 5/5 cartas) en el flop. A su vez, este número se reduce a 6075 (5/6) y en el río a 4824 (5/7). Esto se debe a que 1 o 2 cartas son irrelevantes al clasificar la mano de poker. Un ejemplo es: 76543QK = 7654332 a recta (3 a 7)
Mi simulador se llama Easy Poker y está disponible en mi sitio http://crvltda.webs.com
Árbitro. Pokersoftware.com/forum
Escribí uno en JavaScript . El método de evaluación central utiliza solo manipulaciones de bits, por lo que es extremadamente rápido. Con esto en mente, mirar 21 combinaciones sigue siendo muy rápido. El único momento en que necesitamos profundizar es cuando ocurre un empate. Cuando esto sucede, tenemos que buscar más detalles para ver qué mano de 5 cartas es la mejor. Aquí está la solución que se me ocurrió:
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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ] );
Este sitio incluye una lista de bibliotecas de Poker Hand Evaluator y brinda algunos detalles sobre cada una de ellas. La mayoría de ellos son para 5 manos de cartas, pero hay al menos uno para una mano de 7 cartas llamada The Snezee7 Evaluator . Además, el sitio ofrece una excelente visión general de las diferentes técnicas y algoritmos utilizados para analizar las manos de poker rápidamente.
Utilicé el Keith Rule C # Port del Pokersource Evaluator en algunos proyectos diferentes de póker y creo que es una excelente biblioteca. Hay muchos trucos ingeniosos que puede usar para hacer evaluadores de mano realmente rápidos, pero escribir el código es mucho trabajo y le sugiero que use una biblioteca existente.
Me alegro de que me preguntes :) Sí, aquí hay una solución nueva que puede ser solo la entrada:
Código: code.google.com/p/specialkpokereval
Blog: http://specialk-coding.blogspot.com/2010/04/texas-holdem-7-card-evaluator_23.html
La evolución de este evaluador a nivel comercial está disponible para iPhone / iPod Touch a través de iTunes Store. Se llama " Poker Ace ".
Un excelente resumen de varias soluciones completas con enlaces se encuentra en el blog de James Devlin " Coding The Wheel ".
Un evaluador aún no discutido allí es el de Klaatu''s .
¡Buena suerte!
Por supuesto, si quieres hacerlo muy rápido. El algoritmo que puse antes es demasiado lento.
La tabla7462 debería estar en una matriz, no en un archivo.
Luego, debe precalcular cada 7Card manos diferentes y almacenarlo en una base de datos. Hay 133.784.560 combinaciones de 7 cartas diferentes.
Debe usar este formato (orden alfabético):
"2c2d2h2s3c3d3h" y clasificarlo
Almacene cada 133.784.560 combinaciones diferentes. Hace 52C7 ciclos, lo clasifica y lo almacena en una base de datos. Tal vez en unos días lo tengas listo. Cuando lo tenga listo, ya no necesita 21 combinaciones, simplemente coloque su mano ordenada alfabéticamente y búsquela en su base de datos.
Si lo haces, verás que puedes calcular tus probabilidades contra tus oponentes en tiempo real cada vez que lo necesites.
Créame. No soy un programador y puedo hacerlo. Conozco mis probabilidades en el flop en 3 segundos.
Puedo recomendar https://github.com/chenosaurus/poker-evaluator/
Está escrito en JavaScript y usa un archivo HandRanks.dat de 128 MB.
El código es solo unas pocas líneas y muy fácil de portar a cualquier otro idioma.