Avaliador de mãos de pôquer de 7 cartas
https://stackoverflow.com/questions/2829883
-
26-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Alguém conhece um algoritmo rápido para avaliar mãos de pôquer de 7 cartas?Algo que é mais eficiente do que simplesmente verificar com força bruta cada 21 combinações de mãos de 5 cartas de um conjunto de 7.
Saúde,
Pete
Solução
Este site lista um monte de Bibliotecas de avaliadores de mãos de pôquer e dá alguns detalhes sobre cada um deles.A maioria deles é para mãos de 5 cartas, mas há pelo menos um para mãos de 7 cartas chamado O avaliador Snezee7.Além disso, o site oferece uma excelente visão geral das diferentes técnicas e algoritmos usados para analisar rapidamente as mãos de pôquer.
Eu usei o Port C# da Keith Rule do Pokersource Evaluator em alguns diferentes projetos de pôquer e acho que é uma excelente biblioteca.Existem muitos truques inteligentes que você pode usar para criar avaliadores manuais realmente rápidos, mas escrever o código dá muito trabalho e eu sugiro usar uma biblioteca existente.
Outras dicas
Eu escrevi um em JavaScript. O método principal de avaliação usa apenas manipulações de bits, por isso é extremamente rápido. Com isso em mente, olhar para 21 combinações ainda é muito rápido. A única vez que precisamos ir mais fundo é quando ocorre uma gravata. Quando isso acontece, precisamos analisar mais detalhes para ver qual mão de 5 cartões é realmente a melhor. Aqui está a solução que eu criei:
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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ] );
Que bom que você perguntou :) Sim, aqui está uma nova solução que pode ser apenas o ingresso:
Código: http://code.google.com/p/specialkpokereval/
Blog: http://specialk-coding.blogspot.com/2010/04/texas-holdem-7-card-evaluator_23.html
Uma evolução de grau comercial deste avaliador está disponível para o iPhone/iPod Touch na loja do iTunes. É chamado "Ace de pôquer".
Um excelente resumo de várias soluções completas com links é encontrado no blog de James Devlin "Codificando a roda".
Um avaliador ainda não discutido que existe Klaatu's.
Boa sorte!
Desenvolvi um algoritmo para avaliação manual de 7 cartões sem iterar todas as 21 combinações.
Basicamente, ele divide a mão de 7 cartas em duas categorias: descarregar e não uma descarga. Se for uma descarga, seria fácil procurar o valor em uma tabela de 8192 entradas. Se não for uma descarga, ele executará uma função de hash com técnicas de programação dinâmica e, em seguida, procurará o valor em uma tabela de hash de 49205 entradas.
Se você estiver interessado, verifique meu trabalho no Github.
Eu criei um teste de teste para avaliadores de poker em c aqui. Dos avaliadores que testei, o Poker-Eval A biblioteca foi a vencedora. Showdown de Steve Brecher's Holdem também foi bastante rápido e tinha significativamente menos requisitos de memória. Meu próprio ACE_EVAL segurou seu próprio.
Congratulo -me com ajuda para adicionar outros avaliadores e contribuições dos resultados dos testes de outras máquinas.
Eu acho que você deveria fazer as 21 combinações e usar algum tipo de tabela 7462. 1º: Quaisquer 7 cartões têm 21 combinações diferentes de 5 cartões 2nd: todas as mãos finais possíveis do poker (2.598.960) representam um dos 7462 tipos diferentes de mãos, então é fácil.
Você só precisa olhar para cada 21 combinações de seus cartões e, para cada um, ver o ranking da tabela de classificação 7462. http://www.senspace.com/file/pet0dd
Então, para cada 7 cartões, você terá 21 rankings diferentes desta tabela 7462 que fiz. A classificação mais alta de 21 combinações é a que você deseja conhecer.
Para entender a tabela: em todas as linhas, você tem a mão de 5 cartas (Z para adequado, Y não adequado) e você tem a classificação. Isso só você precisa. Dou -lhe a tabela e um algoritmo de exemplo. Não é realmente o código. É o formato Visual Basic e eu escrevi agora. Provavelmente não funciona, mas você deve entender. O código seria algo assim:
'############### 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
A classificação final é uma variável de mobília. Você deve conhecer sua mão em menos de um segundo. E também é bom comparar com outras mãos, porque você tem o valor da classificação, não o nome dele. E se você quiser fazer algo com algoritmos de poker, é aqui que você deve começar. Com valores de classificação, tudo é rápido e fácil.
Nota: Não sou um programador. Eu sou um quero ser. Eu entendo algumas funções do Visual Basic. Eu sou o que sabia como fazer programas reais. Se o algoritmo funcionar, deixe um comentário. Se você quer que seja muito rápido, não sei como fazê -lo. Eu tenho um algoritmo ultra rápido que me permite verificar (em tempo real) minhas chances contra qualquer oponente em todas as etapas do jogo. Tentei muitos algoritmos para calcular minhas chances no flop em tempo real, mas o mais rápido possível é de 30 segundos. Agora, posso calcular minhas chances no flop em 3 segundos, mas uso um banco de dados de 150 gigabytes com muitas coisas pré-calculadas. Se você quiser saber suas chances em tempo real, deve ter muitas coisas pré-calculadas. Foi assim que eu fiz.
Claro, se você quiser fazer isso muito rápido. O algoritmo que coloquei antes é muito lento.
A tabela7462 Shoul está em uma matriz, não em um arquivo.
Em seguida, você deve pré -calcular as mãos de 7 cartões e armazená -lo em um banco de dados. Existem 133.784.560 combinações diferentes de 7Cards.
Você deve usar este formato (Ordem Alphabeticall):
"2C2D2H2S3C3D3H" e classifique
Armazene a cada 133.784.560 combinações diferentes. Você faz 52C7 CELOS, classifica -o e o armazena em um banco de dados. Talvez em alguns dias você esteja pronto. Quando você estiver pronto, você não precisa mais de 21 combinações, basta colocar sua mão classificada em ordem alfabética e procurá -la no seu banco de dados.
Se você fizer isso, verá que poderá calcular suas chances contra seus oponentes em tempo real sempre que precisar.
Acredite em mim. Eu não sou um programador e posso fazer isso. Eu conheço minhas chances no flop em 3 segundos.
Desenvolvi um simulador Texas Hold'em e, durante esse desenvolvimento, encontrei o número de 7462 combinações únicas (52 - 5/5 cartas) no flop. Por sua vez, esse número cai para 6075 (5/6) e no rio para 4824 (5/7). Isso ocorre porque 1 ou 2 cartões são irrelevantes na classificação da mão do poker. Um exemplo é: 76543qk = 7654332 A Straight (3 a 7)
Meu simulador se chama Easy Poker e está disponível no meu site http://crvltda.webs.com
Ref. Pokersoftware.com/forum
Posso recomendar https://github.com/chenosaurus/poker-evaluator/
Está escrito no JavaScript e usa um arquivo Handranks.dat de 128 MB.
O código é apenas algumas linhas e muito fácil de portar para qualquer outro idioma.
