पोकर हाथ का निर्धारण


19

मैं एक मूल्यांकन के एक भाग के रूप में एक टेक्सास होल्डम गेम बना रहा हूं, और मैं 7 उपलब्ध कार्डों की जांच करने और यह निर्धारित करने के बारे में विचार कर रहा हूं कि क्या मौजूद हैं।

एकमात्र संभव तरीका जो मैं सोच सकता हूं कि कार्ड को संख्यात्मक रूप से क्रमबद्ध करना है, फिर प्रत्येक कार्ड के प्रत्येक संभावित समूह की जांच करें और जांचें कि क्या वे हर एक संभव हाथ की सूची से मेल खाते हैं। सूट के अप्रासंगिक होने के कारण जोड़े के निर्धारण के लिए लंबे समय तक snd केवल संभव होगा।

कार्ड प्रत्येक तार होते हैं, जो एक संख्या / / j / q / k से बना होता है, और एक सूट (char)3(जो थोड़ा सा प्रतीक बनाता है)।

क्या किसी के पास कोई सुझाव, सूत्र या लिंक हैं, जिनका उपयोग मैं एक हाथ-विश्लेषण प्रणाली बनाने में मदद करने के लिए कर सकता हूं?

अभी तक एक दूसरे के खिलाफ हाथों की रैंकिंग के बारे में चिंता न करें, यह मछली का एक अलग केतली है।


1
बस इसे इंगित करते हुए लेकिन इसके संदर्भ में वेक्टर टैग रैखिक बीजगणित के बारे में है। कंटेनर नहीं है।
18

@Sidar भविष्य में टैग संपादित करने के लिए स्वतंत्र महसूस करें यदि आपको लगता है कि वे फिट नहीं हैं। यदि आप टैग और "टैग संपादित करें" विकल्प पर होवर करते हैं (तो कम से कम मेरे लिए?), और आप प्रश्न संपादित किए बिना सिर्फ टैग संपादित कर सकते हैं।
MichaelHouse

@ बाइट 56 मुझे यह सोचने की अजीब आदत है कि मुझे यकीन नहीं है कि अगर मैं सही हूं तो मैं इसे निष्क्रिय रूप से टिप्पणी करना चाहता हूं ... इसलिए मैंने पोस्ट को संपादित नहीं किया है। शायद मुझे पोस्ट में कुछ याद आया, इसलिए मैं उसकी प्रतिक्रिया का इंतजार कर रहा था।
सिदार

यहाँ एक अच्छा लेख भी है जो कुछ साल पहले गेम डेवलपर में दिखाई दिया था: cowboyprogramming.com/2007/01/04/programming-poker-ai
celion

1
मैंने थोड़ी देर के लिए java में एक कार्यान्वयन किया, कुछ समय पहले आप इसे यहाँ पा सकते हैं: codereview.stackexchange.com/questions/10973/… । यदि आप PokerHand.java में देखते हैं, तो आपको प्रत्येक प्रकार के हाथ के परीक्षण के लिए विधियाँ मिलेंगी (उदा। फ़ुलहाउस)। वे केवल तभी काम करते हैं जब कार्ड पहले छांटे जाते हैं।
बूगी

जवाबों:


20

मुझे लगता है कि आप केवल एक रैंक और सूट के कितने कार्ड हाथ में लेकर कितने टेबल बनाकर पोकर हैंड्स पा सकते हैं।

दूसरे शब्दों में, अपने हाथ में उस रैंक के कार्ड की गिनती के लिए एक सरणी मैपिंग कार्ड रैंक (संख्या और A / J / Q / K) बनाएं। यदि खिलाड़ी के पास एक जोड़ी या तीन-प्रकार का है, तो इस सरणी में 2 या 3 के बराबर एक तत्व होगा, आदि यदि उनके पास एक पूर्ण घर है, तो एक तत्व 2 और दूसरा 3, और एक सीधा है। अगर इस सरणी में 1 के बराबर पाँच लगातार तत्व हैं।

इसी तरह आप प्रत्येक सूट के कार्ड की गिनती के समान सरणी बना सकते हैं, और फ्लश का पता लगाने के लिए इसका उपयोग कर सकते हैं।

एक बार जब आप एक विशिष्ट हाथ की उपस्थिति का पता लगा लेते हैं, तो यह बहुत आसान होता है तो वापस जाएं और हाथ में विशिष्ट कार्ड ढूंढें, उन्हें यूआई या आपको जो भी करने की आवश्यकता है, उन्हें उजागर करने के लिए।

छद्मकोश में:

int countByRank[13] = { 0 };        // Initialize counter to zero for each rank
for (cards in hand)
    countByRank[card.rank] += 1;    // Increment counter for this card's rank
if (countByRank.find(2))
    // There's a pair
else if (countByRank.find(3))
    // There's a three-of-a-kind
// etc...

17

यह बहुत मुश्किल है क्योंकि इसमें बहुत सारे संयोजन हैं। सौभाग्य से आपके पास एक प्रोसेसर है जो बहुत कम समय में बड़ी संख्या में संयोजनों की जांच कर सकता है।

विभिन्न प्रकार के हाथों का पता लगाने के लिए आपको कुछ अलग रणनीतियों की आवश्यकता होगी। सौभाग्य से, विभिन्न प्रकार के कुछ रणनीतियों को ओवरलैप कर सकते हैं। मैं हाथ के क्रम से खोजता हूं।

  1. सीधे फ्लश
  2. एक तरह के चार
  3. पूरा घर
  4. लालिमा
  5. सीधे
  6. तीन एक से
  7. दो जोड़ी
  8. एक जोड़ा
  9. हाई कार्ड

2, 3, 6, 7, 8सब सरल गिनती कर रहे हैं। ऐस टू किंग की कार्ड की सूची का उपयोग करके, सूची में प्रत्येक मान की संख्या को जगह दें, प्रत्येक अतिरिक्त कार्ड के लिए इंक्रीमेंट करना। फिर 4s के लिए सूची की जाँच करें, यदि कोई 4s नहीं है, तो आपके पास एक तरह का 4 नहीं है। इसे 3s के लिए जांचें, यदि कोई 3s नहीं है, तो आपके पास एक तरह का 3 नहीं है। यदि आपके पास 3 है, तो 2 के लिए जांचें (पूर्ण घर का संकेत)। और इसी तरह...

के लिए 1, 5आप एक ही सूची का उपयोग कर सकते हैं और अनुक्रमों की तलाश कर सकते हैं जहां सभी कार्डों में 5 कार्डों के अनुक्रम के लिए सूची में एक या एक से अधिक प्रविष्टियां हैं। यदि वे भी एक ही सूट है, यह एक सीधा फ्लश है।

4एक ही सूची सेटअप हो सकता है लेकिन इस बार आप सूट की गिनती कर रहे हैं। 5 या उच्चतर संख्या के लिए देखें।

अंत में 9, आपके पास सबसे अधिक कार्ड है, जो कि आपकी एक सूची से अंतिम उच्चतम मूल्य को देखने का एक साधारण मामला होना चाहिए।

यदि आप क्रम में खोज करते हैं, तो एक बार मैच देखने के बाद आप ब्रेक आउट कर सकते हैं। हालांकि यह खोज जारी रखने और सभी मिलानों को खोजने के लिए तुच्छ होगा यदि आप उपयोगकर्ता को वह सभी जानकारी प्रदान करना चाहते हैं।


अनिवार्य रूप से, आप बाल्टी भर रहे हैं। फिर संयोजनों के लिए बाल्टी की जांच करना। उदाहरण देकर स्पष्ट करने के लिए:

यहाँ छवि विवरण दर्ज करें

प्रत्येक कार्ड के लिए एक बाल्टी के साथ एक सरणी के साथ शुरू करना, कार्ड के माध्यम से पुनरावृत्त करना और प्रत्येक कार्ड के उदाहरण को गिनना। फिर आप आसानी से सरणी को पुनरावृत्त कर सकते हैं और कुछ संयोजनों की जांच कर सकते हैं। इस उदाहरण में, यह स्पष्ट है कि एक तरह का 4 है क्योंकि एक बाल्टी में 4 आइटम हैं।


6

मैं एक बार इस एल्गोरिथ्म में टकरा गया। यह हाथों को निर्धारित करने के लिए अभाज्य संख्याओं को गुणा करता है और एक बहुत ही रोचक रीडिंग है। कैक्टस केव का पोकर हैंड इवैल्यूएटर


1
यह एक दिलचस्प है, लेकिन मुझे यकीन नहीं है कि आप इसे पढ़ेंगे। वह एल्गोरिथ्म 5 कार्ड के लिए है । आप Google कार्ड में 7 कार्ड से संबंधित खोज कर सकते हैं, जैसा कि लेखक बताता है कि उनके पास 7 कार्ड के लिए एक एल्गोरिथ्म है, लेकिन इसे साझा नहीं कर रहे हैं। पृष्ठ के शीर्ष के पास ग्रे टेक्स्ट देखें। इसलिए मुझे यकीन नहीं है कि 7 कार्ड सेट के लिए एल्गोरिथ्म कितना उपयोगी है।
MichaelHouse

1
चूंकि केवल 21 अलग-अलग 5 कार्ड हाथ हैं जो 7 कार्ड हाथ से बनाए जा सकते हैं एक विकल्प प्रत्येक पर 5 कार्ड मूल्यांकनकर्ता का उपयोग करना है, और सबसे अच्छा चुनना है।
एडम

@ बाइटे 56 आप सही कह रहे हैं, मुझे याद है कि मैंने इसे 7 कार्ड के लिए इस्तेमाल किया था, लेकिन पहले से सबसे अच्छा 5 कार्ड का निर्धारण करना था, जो प्रभावकारिता को कम करता था।
पेट्रवाज़

इस उत्तर पर लिंक के बाद से रॉट हो गया है, और डोमेन एक स्पैमर द्वारा उठाया गया है। मैंने मूल पृष्ठ के संग्रह के लिंक को पुनर्निर्देशित किया है, लेकिन इस उत्तर को और अधिक मजबूत बनाने के लिए यह उत्तर के शरीर के भीतर प्रस्तावित एल्गोरिथ्म का सारांश शामिल करने के लिए उत्तर को संपादित करने के लिए आदर्श होगा।
DMGregory

2

उत्कृष्ट उत्तरों के पूरक के लिए यह प्रश्न पहले ही मिल गया है, मुझे लगा कि मूल वर्गीकरण तकनीक के एक बार हाथों की तुलना करने के सबसे सरल तरीकों में से एक की पेशकश करना सहायक होगा। सबसे पहले, आप अपनी कक्षा के साथ हाथों को टैग करना चाहेंगे , क्योंकि कई उत्तर सुझाए गए हैं - आपकी अधिकांश तुलना 'हैंड एक्स हाथ से बेहतर है?' फिर दोनों हाथों की कक्षाओं की तुलना करके और यह देखा जा सकता है कि कौन सी कक्षा बेहतर है। बाकी के लिए, आपको वास्तव में कार्ड-बाय-कार्ड के आधार पर तुलना करने की आवश्यकता होगी, और यह पता चला है कि वर्गीकरण में थोड़ा और अधिक काम यह आसान बना देगा।

बेसलाइन मामले के रूप में, उस स्थिति पर विचार करें जहां दोनों हाथ 'उच्च कार्ड' हाथ हैं; इस स्थिति में, आप पहले दो उच्चतम कार्डों की तुलना करेंगे, फिर (यदि वे मिलान किए गए) अगले दो कार्ड्स इत्यादि। इस:

int CompareHandsOfSameClass(Hand h1, Hand h2) {
  for ( int i = 0; i < 5; i++ ) {
    if ( h1[i].rank > h2[i].rank ) {
      return -1;
    } else if ( h1[i].rank < h2[i].rank ) {
      return 1;
    }
  }
  return 0;
}

अब, अच्छी खबर: यह पता चलता है कि यह शाब्दिक आदेश , उपयुक्त रूप से ट्वीक किया गया है, किसी भी में दो हाथों की तुलना करने के लिए काम करता हैकक्षाओं के रूप में, जब तक कि उनकी कक्षा समान है। उदाहरण के लिए, चूंकि जोड़े की तुलना करने का तरीका पहले जोड़े की तुलना करना है, फिर अन्य तीन कार्ड, आप जोड़ी को पहले रखने के लिए अपना हाथ छांट सकते हैं (या पहले जोड़ी का एक कार्ड भी!) और इसी तुलना को चलाएं। (इसलिए, उदाहरण के लिए, A9772 की तरह एक हाथ 77A92 या बेहतर अभी तक, 7A927 के रूप में संग्रहीत किया जाएगा; हाथ A9972 को 9A729 के रूप में संग्रहीत किया जाएगा, और उपरोक्त कोड के साथ तुलना करके आप 9 के खिलाफ 7 पेज शुरू करेंगे और पाएंगे कि A9972 जीता)। दो जोड़ी का एक हाथ पहले दो जोड़े के उच्च के साथ संग्रहीत किया जाएगा, फिर निचले, फिर 'किकर' (इसलिए, ए 9977 97A97 के रूप में संग्रहीत किया जाएगा); एक प्रकार के तीन को पहले तीन के एक कार्ड के साथ संग्रहीत किया जाएगा, फिर किकर्स, फिर अन्य कार्ड (जैसे, ए 7772 7 ए 277); एक पूर्ण घर अपने तीन में से एक के साथ संग्रहीत किया जाएगा और फिर उसके दो में से एक (जैसे, 99777 79779 के रूप में संग्रहीत किया जाएगा); और स्ट्रैट्स और फ्लश दोनों को 'डायरेक्ट लेक्सिकोग्राफ़िक' ऑर्डर में स्टोर किया जा सकता है क्योंकि दोनों की तुलना ऐसे की जाती है जैसे हाई-कार्ड हाथों में होती है। इससे एक सीधा बाहरी तुलनित्र कार्य होता है जो पहले से दिए गए फ़ंक्शन के साथ सभी वर्गों के लिए काम करता है:

// Compare two hands, returning -1/0/+1 as hand 1 is less than, equal to,
// or greater than hand 2. Note that this function assumes the hands have
// already been classified and sorted!
int CompareHands(Hand h1, Hand h2) {
  if ( h1.handClass > h2.handClass ) {
    return -1;
  } else if ( h1.handClass < h2.handClass ) {
    return 1;
  } else {
    return CompareHandsOfSameClass(h1, h2);
  }
}

उम्मीद है कि यह कुछ मदद की जाएगी!


1

उपयुक्त कार्ड अभ्यावेदन और बिट-ट्विडलिंग का उपयोग करके कुछ समानताएँ संभव हैं। उदाहरण के लिए, यह जावा कोड एक पूर्णांक को लौटाने वाली 7-कार्ड की कठिनाइयों का मूल्यांकन करता है जिसका उपयोग दो हाथों की तुलना के लिए किया जा सकता है। इसे हाथ के प्रकार को अधिक उपयोगकर्ता-अनुकूल तरीके से रिपोर्ट करने के लिए अनुकूलित किया जा सकता है। पहले के उत्तर में संदर्भित कैक्टस केव के पृष्ठ से मुख्य विचार आते हैं।

यदि आप दक्षता और कोड स्पष्टता के बजाय विभिन्न भाषाओं में हाथ को नामांकित करने के लिए केवल संभावित कार्यान्वयन में रुचि रखते हैं, तो आप codegolf.SE पर पोकर हैंड चैलेंज का नाम भी देख सकते हैं ।


1

सबसे पहले, आपको सभी कार्डों के रैंक और सूट को जानना होगा; तुच्छ लेकिन आवश्यक।

फिर, इन 7 कार्डों के माध्यम से स्पिन करें और दो हिस्टोग्राम बनाएं; एक रैंक के आधार पर (13 इंडेक्स के साथ एक सरणी का उपयोग करके, सभी को शून्य से शुरू किया गया और 1 से बढ़ाकर जब 1 और उस रैंक के साथ हाथ में एक कार्ड मिलता है) और एक सूट के अनुसार (चार तत्वों की एक सरणी का उपयोग करके रैंक के समान निर्माण) । ये लीनियर ऑपरेशंस हैं और आप प्रत्येक कार्ड के लिए ट्रैवर्सल्स के केवल एक सेट के लिए दोनों ऑपरेशन कर सकते हैं।

फिर आप यह निर्धारित कर सकते हैं कि मापदंड का मिलान करने वाली बाल्टियों के लिए प्रत्येक हिस्टोग्राम की जांच करके निम्नलिखित में से कोई भी मौजूद है, और / या एक साधारण अनुवर्ती परीक्षण:

  • जोड़ी: क्या वास्तव में एक रैंक की बाल्टी का मूल्य ठीक 2 है, किसी अन्य बाल्टी का मूल्य 1 से अधिक नहीं है और कोई फ्लश नहीं है?
  • दो जोड़ी: क्या दो या दो से अधिक रैंक की बाल्टियों का मूल्य ठीक 2 है, कोई बाल्टी 2 से अधिक नहीं है और कोई फ्लश नहीं है? (स्पष्ट रूप से तीन जोड़ी हाथ नहीं है, लेकिन यह सात कार्ड दिए जाने की संभावना है; सबसे मजबूत दो जोड़ी खिलाड़ी का हाथ है)
  • TOAK: क्या वास्तव में एक बाल्टी का मूल्य ठीक 3 है, किसी अन्य बाल्टी का मूल्य 1 से अधिक है और कोई फ्लश नहीं है?
  • स्ट्रेट: क्या लगातार पांच रैंक वाली बकेट्स का मूल्य 1 या अधिक है, जिसमें फ्लश नहीं है? (यह मत भूलो कि इक्के उच्च और निम्न दोनों हैं; आप 14 तत्वों के रैंक हिस्टोग्राम का उपयोग कर सकते हैं और यदि आप चाहें तो इक्के को दो बाल्टी में गिन सकते हैं)
  • फ्लश: क्या किसी भी सूट की बाल्टी में 5 या अधिक कार्ड हैं? (यदि हां, तो उस सूट के कार्ड के लिए हाथ को स्कैन करें और शीर्ष 5 चुनें)
  • पूर्ण सभा: क्या किसी एक रैंक की बाल्टी का मूल्य 3 है और किसी अन्य बाल्टी का मूल्य 2 है (7 कार्ड के साथ, एक फ्लश एक पूर्ण घर के साथ असंभव है जब तक कि आप एक पिनोले डेक के साथ नहीं खेल रहे हों)
  • चार की तरह: क्या किसी एक रैंक का मूल्य 4 है? (कोई अन्य संयोजन संभव नहीं होना चाहिए)
  • स्ट्रेट फ्लश: क्या हिस्टोग्राम्स द्वारा इंगित किया गया स्ट्रेट और फ्लश दोनों है ? यदि ऐसा है, तो संकेतित फ्लश सूट में कम से कम एक कार्ड है जो कि सीधे संकेतित प्रत्येक रैंक से मेल खाता है? (यह संभवतः सबसे अधिक कम्प्यूटेशनल रूप से महंगा है, लेकिन यह गिनने के लिए सरल होना चाहिए कि कितने लगातार रैंक हैं, और आपको केवल 5 गर्भधारण योग्य रैंकों के लिए एक बार हाथ को स्कैन करना होगा, 6 के लिए दो बार और 7 के लिए तीन बार।)

आप, स्वाभाविक रूप से, इनमें से कई जाँचों को जोड़ सकते हैं:

  • क्या कोई फ्लश है?
  • क्या कोई सीधा है?
    • यदि दोनों हैं, तो क्या यह एक सीधा फ्लश है?
    • यदि यह एक सीधा फ्लश है, तो क्या इसमें ऐस और किंग दोनों हैं?
  • क्या कोई चार-तरह का है?
  • कितने तीन प्रकार के होते हैं? (दो, यह एक पूर्ण घर है। एक, जोड़े की जाँच करें)
  • कितने जोड़े हैं? (दो या अधिक के साथ, यह दो जोड़ी है। एक के साथ, यदि कोई तीन भी है तो यह एक पूर्ण घर है, अन्यथा यह एक जोड़ी है)
  • उपरोक्त में से कोई नहीं (उच्च कार्ड)।

मूल रूप से, यदि किसी भी हाथ से इन उपज का उत्तर मिलता है, तो हाथ की ताकत के लिए परिणामी "हाथ की ताकत" मान सेट करें, यदि मूल्य पहले से अधिक नहीं है। उदाहरण के लिए, यदि आपके पास एक पूरा घर है, तो 7 की ताकत 7 है, तो आपके पास एक तरह की तीन, शक्ति 4, और एक जोड़ी, शक्ति 2 है।

कुछ शॉर्टकट हैं और तेज़ आउटसाइड हैं, लेकिन कुल मिलाकर यह वास्तव में इतना महंगा नहीं है कि सभी चेक को चला सकें ।


0

आप एक सरल पुनरावृत्ति दृष्टिकोण के साथ अपेक्षाकृत आसानी से पोकर हाथ कर सकते हैं।

प्रत्येक कार्ड के लिए, जाँच करें कि जोड़ी के लिए जाँच करने के लिए एक ही चेहरे के साथ एक या दो या तीन अन्य हैं या एक तरह के तीन / चार।

पूर्ण घर समान हैं। या यदि आप एक जोड़ी और तीन तरह के तीन पाते हैं जो समान चेहरा नहीं हैं, तो एक पूर्ण घर को चिह्नित करें।

फ्लश के लिए, प्रत्येक सूट को यह देखने के लिए जांचें कि क्या एक ही सूट के पांच हैं।

सीधे चेक करना आसान है, भले ही अनसोल्ड हो। प्रत्येक कार्ड के लिए, जांचें कि क्या कोई उच्च है, और तब तक दोहराएं जब तक कि लगातार पांच कार्ड नहीं मिलते हैं या नहीं।

रॉयल फ्लश और स्ट्रेट फ्लश को स्ट्रैट्स के समान पाया जा सकता है। रॉयल फ्लश में कुछ अतिरिक्त स्थितियां हैं जिन्हें कम मूल्यवान कार्डों को अनदेखा किया जा सकता है।

हां, यह दृष्टिकोण अक्षम है, लेकिन अधिकांश पोकर खेलों के लिए, यह अप्रासंगिक है। आप हर आधे मिनट में छोटे खिलाड़ियों की जाँच कर रहे हैं, प्रति सेकंड हजारों हाथों की जाँच नहीं कर रहे हैं।

बेहतर तरीके मौजूद हैं, लेकिन कोड के लिए अधिक समय लग सकता है, और आपके पास एल्गोरिदम की चतुराई और दक्षता के अलावा खिलाड़ियों के दृष्टिकोण से बेहतर खेल के लिए समय / पैसा खर्च करने के लिए अधिक महत्वपूर्ण चीजें होंगी।


0

जोड़े, डबल जोड़े, टोक्स, पूर्ण घरों, पोकर्स आदि को खोजने का एक सरल तरीका निम्नलिखित है:

इस तरह से एक नेस्टेड लूप में एक दूसरे के साथ प्रत्येक कार्ड की तुलना करें:

int matches=0;
for (int i=0;i<5;i++)
   for (int j=0;j<5;j++)
      if (i!=j && cardvalue(card[j])==cardvalue(card[i])) matches++;

मैच निम्नलिखित पकड़ेंगे :
एक जोड़ी के लिए २ एक जोड़ी के लिए
४ दो जोड़े के लिए
६ तोक
8 के लिए एक फ़ुलहाउस
१२ के लिए पोकर

इसे तेज करने के लिए: इसे j-loop को 5 तक चलाने की जरूरत नहीं है, इसे i-1 तक चलाया जा सकता है। तुलना "i! = j" को फिर हटाया जा सकता है, मैच के लिए मानों को आधा कर दिया जाता है (1 = जोड़ी, 2 = 2 वर्ग) आदि।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.