क्या कोई 7 कार्ड पोकर हाथों का मूल्यांकन करने के लिए एक तेज़ एल्गोरिदम जानता है? कुछ जो केवल जानवर बल 7.7 कार्ड पोकर हैंड मूल्यांकनकर्ता
चीयर्स का एक सेट से हाथ की एक हर 21 5-कार्ड संयोजन जाँच से अधिक कुशल है,
पीट
इस साइट में Poker Hand Evaluator libraries का एक समूह सूचीबद्ध करता है और देता है उनमें से प्रत्येक के बारे में कुछ विवरण। उनमें से ज्यादातर 5 कार्ड हाथों के लिए हैं, लेकिन 712 हाथों के लिए कम से कम एक है जिसे The Snezee7 Evaluator कहा जाता है। इसके अलावा साइट पोकर हाथों का त्वरित विश्लेषण करने के लिए उपयोग की जाने वाली विभिन्न तकनीकों और एल्गोरिदम का एक शानदार अवलोकन प्रदान करती है।
मैंने कुछ अलग poker projects में पोकरसोर्स इल्यूलेटर के कीथ नियम सी # पोर्ट का उपयोग किया है और लगता है कि यह एक उत्कृष्ट पुस्तकालय है। वास्तव में तेज़ हाथ मूल्यांकन करने के लिए आप कई चालाक चाल का उपयोग कर सकते हैं, लेकिन कोड लिखना बहुत काम है और मैं मौजूदा पुस्तकालय का उपयोग करने का अत्यधिक सुझाव दूंगा।
ध्यान दें कि स्नीज़ी 7 को 266 एमबी लुकअप टेबल की आवश्यकता है। –
यह करता है ... लेकिन इस तरह आप एक तेज़ हाथ मूल्यांकनकर्ता (पूर्व-गणना के बहुत सारे) प्राप्त करते हैं। दो प्लस दो मूल्यांकनकर्ता 123 एमबी लुकअप टेबल का उपयोग करके 7 कार्ड हाथों का मूल्यांकन करने के लिए एक समान दृष्टिकोण का उपयोग करते हैं। 5 कार्ड हाथों के लिए लुकअप टेबल बहुत छोटे हैं। –
लापरवाह प्लग - उपरोक्त में से कुछ के रूप में तेज़ नहीं है, मेरे पास ऐसा कोई है जो ~ 70M हाथ/एस को यहां कोई टेबल का उपयोग नहीं करता है: https://github.com/ashelly/ACE_eval। – AShelly
खुशी है कि आप से पूछा :) हाँ, यहाँ एक नया समाधान सिर्फ टिकट हो सकता है कि है:
कोड: http://code.google.com/p/specialkpokereval/
ब्लॉग: http://specialk-coding.blogspot.com/2010/04/texas-holdem-7-card-evaluator_23.html
इस मूल्यांकनकर्ता के एक वाणिज्यिक ग्रेड विकास के लिए उपलब्ध है iTunes स्टोर के माध्यम से आईफोन/आईपॉड टच। इसे "Poker Ace" कहा जाता है।
जेम्स डेवेलिन के ब्लॉग "Coding The Wheel" पर लिंक के साथ पूर्ण समाधानों का एक उत्कृष्ट सारांश मिलता है।
एक मूल्यांकनकर्ता ने अभी तक चर्चा नहीं की है Klaatu's है।
शुभकामनाएं!
मैंने आपके मूल्यांकनकर्ता को [राउंडअप] (https://github.com/ashelly/pet) में जोड़ा है। मैं किसी भी प्रतिक्रिया की सराहना करता हूं। – AShelly
मैंने जावास्क्रिप्ट में एक लिखा था। कोर मूल्यांकन विधि केवल बिट मैनिप्लेशंस का उपयोग करती है, इसलिए यह बेहद तेज़ है। इस बात को ध्यान में रखते हुए, 21 संयोजनों को देखते हुए अभी भी बहुत तेज़ है। जब एक टाई होती है तो हमें गहराई से जाने की आवश्यकता होती है। जब ऐसा होता है, तो हमें यह देखने के लिए और अधिक विवरण देखना होगा कि कौन सा 5 कार्ड हाथ वास्तव में सबसे अच्छा है।
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], [ _["♠"], _["♠"], _["♠"], _["♠"], _["♠"] ]);
इस प्रयास में बहुत सारे प्रयास किए गए! +1 :) –
वह एक चुड़ैल है! बहुत बढ़िया लेख। –
इस कोड में एक बग है - यदि आपके पास एक ऐस के साथ सीधे कार्ड के रूप में सीधे है (उदा। ♣ 2 ♦ 3 ♦ 4 ♠ 5 ♥ 6 ♦ के ♥) तो यह गलत * सीधे * सीधे चुनता है। इस उदाहरण में 6 ♦ उच्च सीधे सबसे अच्छा होना चाहिए। ऐसा इसलिए है क्योंकि यह ऐस को अतिरिक्त वजन दे रहा है लेकिन इस मामले में ऐसा करना गलत है क्योंकि यह उच्च सीधे नहीं बल्कि सीधे सीधे है। https://imgur.com/a/e9wGR – wal
मुझे लगता है कि आप 21 संयोजनों करते हैं और 7462 तालिका किसी तरह का उपयोग करना चाहिए: यहाँ समाधान मैं के साथ आया है। पहला: किसी भी 7 कार्ड्स में 21 अलग-अलग 5 कार्ड संयोजन होते हैं दूसरा: प्रत्येक संभावित अंतिम पोकर हाथ (2.5 9 8.9 60) 7462 विभिन्न प्रकार के हाथों में से एक का प्रतिनिधित्व करता है , तो यह आसान है।
आपको बस अपने कार्ड के हर 21 संयोजनों को देखना होगा और प्रत्येक के लिए, 7462 रैंकिंग तालिका की रैंकिंग देखें। http://www.sendspace.com/file/pet0dd
फिर, प्रत्येक 7 कार्ड के लिए आपके पास इस 7462 तालिका से 21 अलग-अलग रैंकिंग होंगी। 21 संयोजनों की सर्वोच्च रैंकिंग वह है जिसे आप जानना चाहते हैं।
तालिका को समझने के लिए: प्रत्येक पंक्ति में आपके पास 5 कार्ड हैंड (उपयुक्त के लिए जेड, वाई गैर-उपयुक्त) और आपके पास इसकी रैंकिंग है। यही केवल आपको चाहिए। मैं आपको टेबल और एक उदाहरण एल्गोरिदम देता हूं। यह वास्तव में कोड नहीं है।यह दृश्य मूल प्रारूप है और मैंने इसे अभी लिखा है। शायद काम नहीं करता है लेकिन आपको समझना चाहिए। कोड इस तरह कुछ होगा:
'############### 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
अंतिम रैंकिंग myranking चर है। आपको एक सेकंड से भी कम समय में अपना हाथ पता होना चाहिए। और अन्य हाथों से तुलना करना भी अच्छा है, क्योंकि आपके पास रैंकिंग मूल्य का नाम नहीं है। और यदि आप पोकर एल्गोरिदम के साथ कुछ करना चाहते हैं, तो यह वह जगह है जहां आपको शुरू करना चाहिए। रैंकिंग मूल्यों के साथ सबकुछ त्वरित और आसान है।
नोट: मैं प्रोग्रामर नहीं हूं। मैं बनना चाहता हूँ मैं कुछ दृश्य बुनियादी कार्यों को समझता हूं। मुझे लगता है कि मैं असली कार्यक्रम कैसे बनाना चाहता था। अगर एल्गोरिदम काम करता है, तो कृपया एक टिप्पणी छोड़ दें। यदि आप इसे बहुत तेज़ होना चाहते हैं, तो मुझे नहीं पता कि यह कैसे करना है। मुझे लगता है कि मेरे पास एक अल्ट्रा फास्ट एल्गोरिदम है जो मुझे खेल के हर चरण में किसी भी विरोधियों के खिलाफ मेरी बाधाओं (वास्तविक समय में) की जांच करने की अनुमति देता है। मैंने वास्तविक समय में फ्लॉप पर अपनी बाधाओं की गणना करने के लिए कई एल्गोरिदम की कोशिश की लेकिन सबसे तेज़ मैं 30 सेकंड कर सकता हूं। अब, मैं 3 सेकंड में फ्लॉप पर अपनी बाधाओं की गणना कर सकता हूं लेकिन मैं 150 गीगाबाइट डेटाबेस का उपयोग करता हूं जिसमें कई चीजें पूर्व-गणना की जाती हैं। यदि आप वास्तविक समय में अपनी बाधाओं को जानना चाहते हैं तो आपके पास कई चीजें पूर्व-गणना की जानी चाहिए। मैंने ऐसा किया है।
बेशक, यदि आप इसे बहुत तेज़ करना चाहते हैं। पहले मैंने डाला एल्गोरिदम बहुत धीमा है।
तालिका 7462 शॉल एक सरणी में हो, फ़ाइल में नहीं।
फिर, आपको प्रत्येक अलग-अलग 7 कार्ड हाथों को सटीक बनाना चाहिए और इसे डेटाबेस में संग्रहीत करना चाहिए। 133.784.560 विभिन्न 7 कार्ड संयोजन हैं।
आप इस प्रारूप (alphabeticall क्रम) उपयोग करना चाहिए:
"2c2d2h2s3c3d3h" और रैंक यह
स्टोर हर 133.784.560 विभिन्न संयोजनों। आप 52 सी 7 कण करते हैं, इसे रैंक करते हैं और इसे डेटाबेस में स्टोर करते हैं। शायद कुछ दिनों में आप इसे तैयार कर लेंगे। जब आप इसे तैयार करते हैं, तो आपको 21 संयोजनों की आवश्यकता नहीं है, बस अपना हाथ वर्णानुक्रम में क्रमबद्ध करें और अपने डेटाबेस में इसकी खोज करें।
यदि आप ऐसा करते हैं, तो आप देखेंगे कि जब भी आपको आवश्यकता हो, आप वास्तविक समय में अपने विरोधियों के खिलाफ अपनी बाधाओं की गणना कर सकते हैं।
मेरा विश्वास करो। मैं प्रोग्रामर नहीं हूं और मैं इसे कर सकता हूं। मैं 3 सेकंड में फ्लॉप पर मेरी बाधाओं को जानता हूं।
मैंने एक सिम्युलेटर टेक्सास होल्डम विकसित किया और इस विकास के दौरान मुझे फ्लॉप पर 7462 अद्वितीय संयोजन (52 - 5/5 कार्ड) की संख्या मिली। बदले में, यह संख्या 6075 (5/6) और नदी में 4824 (5/7) तक गिर जाती है। ऐसा इसलिए है क्योंकि पोकर हाथ वर्गीकृत करने में 1 या 2 कार्ड अप्रासंगिक हैं। एक उदाहरण है: 76543QK = 7,654,332 एक सीधी (3 से 7)
मेरे सिम्युलेटर आसान पोकर कहा जाता है और अपनी साइट http://crvltda.webs.com
रेफरी में उपलब्ध है। Pokersoftware.com/forum
मैंने सी here में पोकर मूल्यांकनकर्ताओं के लिए टेस्टबेड बनाया है। मूल्यांकन किए गए मूल्यांकनकर्ताओं में से poker-eval लाइब्रेरी विजेता थी। Steve Brecher's Holdem Showdown भी काफी तेज़ था और इसमें काफी कम स्मृति आवश्यकताएं थीं। मेरा खुद का ACE_Eval इसे स्वयं का रखता है।
मैं अन्य मूल्यांकनकर्ताओं और अन्य मशीनों से परीक्षण परिणामों के योगदान जोड़ने में सहायता का स्वागत करता हूं।
देखें मुझे स्टीव ब्रेचर के मूल्यांकनकर्ता पर अच्छा लगा, लेकिन मुझे अपने 0x0V0RRRRR eval परिणाम से कार्ड मान निकालने में कठिनाई हो रही है। क्या आप अपने मानक के बीएचएस अनुभाग में एक और विस्तृत डिकोडर जोड़ सकते हैं? – JSON
मैं उस पर पहुंचने की कोशिश करूंगा, लेकिन इस बीच: 5 'आर' निबल्स हैं, जहां '0'..' सी '' 2 'का प्रतिनिधित्व करता है ..' ऐस '। वे हाथ रैंक बनाने वाले कार्ड के मूल्यों का प्रतिनिधित्व करते हैं। पीछे की ओर 0 को नजरअंदाज कर दिया गया है। आपको यह निर्धारित करने के लिए रैंक को देखने की आवश्यकता है कि कितने मूल्य निकाले जाएंगे। तो 7 किक के साथ 4 एसेस के लिए, आपके पास 'सी 5000' होगा। 3 एस से अधिक पूर्ण हाउस किंग्स के लिए, आपको 'बी 1000' मिलता है। एक रानी किकर के साथ दो जोड़े, 8s और 4s '62A00' है। इत्यादि। एक हाई-कार्ड हाथ सभी 5 निबल्स का उपयोग करेगा। ACE_Eval।एच एक समान प्रतिनिधित्व का उपयोग करता है। विजेता कार्ड प्राप्त करने के लिए एक तरीके से 'ACE_decode()' देखें। – AShelly
मैंने सभी 21 संयोजनों को दोबारा किए बिना 7-कार्ड हाथ मूल्यांकन के लिए एक एल्गोरिदम विकसित किया।
असल में, यह 7-कार्ड हाथ को दो श्रेणियों में विभाजित करता है: फ्लश और फ्लश नहीं। यदि यह फ्लश है, तो 8192 प्रविष्टियों की तालिका में मान देखना आसान होगा। यदि यह फ्लश नहीं है, तो यह गतिशील प्रोग्रामिंग की तकनीकों के साथ हैश फ़ंक्शन चलाएगा, और उसके बाद 49205 प्रविष्टियों की हैश तालिका में मान देखेंगे।
यदि आप रुचि रखते हैं, तो कृपया github पर अपना काम देखें।
अच्छा सवाल है, लेकिन मुझे लगता है कि आप से बेहतर सिर्फ 21 संयोजनों की जाँच के बजाय शॉर्टकट के लिए कुछ पागल नौटंकी पता लगाने की कोशिश कर रहे हैं। –
@ डेविड वास्तव में, सच से कुछ और नहीं हो सकता है। लोगों ने तेजी से 7 कार्ड मूल्यांकनकर्ताओं को लिखने में काफी प्रयास किए हैं। जब आप लाखों हाथ एक सेकंड करना चाहते हैं, तो गति महत्वपूर्ण हो जाती है। –
@ डेविड: बहुत बेहतर तरीके हैं जो पढ़ने के लिए आसान हैं और किसी भी प्रकार की सॉर्टिंग की आवश्यकता नहीं है। वे इसके लिए तीव्रता के कई आदेश भी तेज हैं। एक उदाहरण है - अहम - यहां पाया गया: http://code.google.com/p/specialkpokereval/। – SK9