पोकर फेस
परिचय
लियो को पोकर खेलने में मजा आता है, लेकिन टेक इंक में उसकी नौकरी भी उसके लिए बहुत अच्छी तरह से सीखने की मांग है। लियो, एक कंप्यूटर वैज्ञानिक होने के नाते, हतोत्साहित नहीं है। उन्होंने पोकर को सीखने में जितना समय लिया है, उससे अधिक समय लेने का फैसला किया है, और इसे बेहतर तरीके से खेलने में मदद करने के लिए पोकर बॉट लिखने के लिए इसका उपयोग करें। लेकिन अब लियो के पास एक समस्या है: यह समझने के लिए कि थोड़ा बेहतर कैसे खेलें, लियो को कई "लोगों" के कई खेलों का पालन करने की आवश्यकता है, लेकिन "लोगों" को खेल की गुणवत्ता और वास्तविकता में सुधार करने के लिए अलग-अलग खेल शैलियों की आवश्यकता होती है।
चुनौती
लियो याद करते हैं कि वास्तव में प्रोग्रामिंग चुनौतियों के लिए समर्पित एक वेबसाइट है, और आपकी मदद के लिए सूची तैयार कर रहा है! आपका काम एक प्रोग्राम लिखना है जो "पोकरफेस" को 5-कार्ड पोकर का संशोधित संस्करण निभाता है। आप जो भी प्रारूप चाहते हैं, कार्यक्रम 5-कार्ड हाथ के रूप में इनपुट लेगा, जिसके बाद कार्यक्रम आउटपुट होगा:
- बिल्कुल (केस-संवेदी) "सही" "1" या "टी" यदि खिलाड़ी कार्डों का आदान-प्रदान करना चाहता है, तो कोई अन्य गैर-खाली नमूना नहीं।
- यदि सही है, तो कार्ड और / या कार्ड के सूचकांकों की सूची खिलाड़ी को एक्सचेंज करने की इच्छा है।
- 0 और 3 के बीच एक एकल संख्या, जो यह निर्दिष्ट करती है कि खिलाड़ी कितने अतिरिक्त कार्ड चाहता है।
- खिलाड़ी उपयोग करने के लिए हाथ बाहर प्रिंट करें।
(नीचे प्रारूपण देखें)
पोकरफेस नियम
- चूंकि पोकरफेस एक टेक्स्ट-आधारित साहसिक खेल है, इसलिए कार्ड को एक सुसंगत तरीके से प्रस्तुत किया जाना चाहिए। कार्ड को दो वर्ण कोड द्वारा दर्शाया जाता है, पहला चरित्र सूट है, और दूसरा कार्ड का नाम है।
- पत्ते:
- 2-9 = 2-9
- 10 = टी
- जैक = जे
- रानी = क्यू
- राजा = के
- ऐस = ए
- सूट:
- हुकुम = एस
- क्लब = सी
- दिल = एच
- हीरा = डी
- पत्ते:
तो हुकुम का इक्का SA होगा, 10 दिलों का HT है, 4 का हीरों का D4 है, आदि।
- पोकरफेस के एक दौर में चार चरण होते हैं:
- डेक को फेरबदल किया जाता है और प्रत्येक खिलाड़ी को पांच कार्ड हाथ में दिए जाते हैं।
- प्रत्येक खिलाड़ी को जितने चाहें उतने कार्ड का आदान-प्रदान करने का मौका दिया जाता है।
- प्रत्येक खिलाड़ी को तीन और कार्ड हासिल करने का मौका दिया जाता है।
- प्रत्येक खिलाड़ी को अपना सर्वश्रेष्ठ हाथ प्रकट करना चाहिए।
- सबसे अच्छा हाथ जीतता है, और उस खिलाड़ी को एक बिंदु मिलता है। टाई होने की स्थिति में दोनों खिलाड़ियों को एक अंक मिलता है।
- एक एकल गेम में, दस राउंड खेले जाते हैं और सबसे अधिक अंक जीतने वाला खिलाड़ी एकल "जीत बिंदु" जीतता है। टाई होने की स्थिति में, दोनों खिलाड़ी एक जीत हासिल करते हैं।
- लियो के पास वास्तव में बहुत बड़ी राशि नहीं है, इसलिए आपके बॉट मान सकते हैं कि यह कोई सट्टेबाजी के साथ एक आदर्श दुनिया है।
हाथ
इनपुट आउटपुट
- लियो केवल जावा को जानता है, इसलिए आपके प्रोग्राम को प्रोसेस एपीआई (कमांड लाइन) के माध्यम से निष्पादन योग्य होना चाहिए , और क्रमशः इनपुट और आउटपुट के लिए STDIN और STDOUT का उपयोग करना चाहिए ।
- ऊपर दिए गए इनपुट और आउटपुट के प्रत्येक चरण के लिए, इनपुट और आउटपुट प्रत्येक को एक पंक्ति में मौजूद होना चाहिए।
- अंतिम आउटपुट के बाद कम से कम एक अनुगामी नई लाइन होनी चाहिए। (यह STDIN से इनपुट पढ़ने के तरीके के कारण है)
- अनुगामी और प्रमुख स्थानों के अलावा किसी भी बाहरी इनपुट / आउटपुट की अनुमति नहीं है। पार्सर बस चीजों को समझ नहीं पाता है जैसे
final_hand=...याdraw 0। - ड्राइंग करते समय, आउटपुट एक पूर्णांक होता है, जब आउटपुट का आदान-प्रदान पूर्णांक और / या नीचे परिभाषित कार्ड की एक सूची है, और जब मूल हाथ से निपटा जा रहा है, तो आउटपुट नीचे परिभाषित कार्ड की एक सूची है।
- सभी इनपुट / आउटपुट नंबर आधार 10 में सकारात्मक पूर्णांक होने चाहिए।
- आप कार्ड इनपुट के लिए प्रारूप को परिभाषित कर सकते हैं (नीचे पोस्ट प्रारूप देखें)।
- सच को "सही," "1" या "टी" के रूप में परिभाषित किया गया है और गलत किसी भी अन्य गैर-खाली मूल्य है।
- विनिमय चरण के दौरान:
- कार्ड सूचकांकों को उनके बीच कम से कम एक स्थान के साथ आउटपुट होना चाहिए (जैसे
3 4 0) - कार्ड का नाम उनके बीच कम से कम एक जगह होना चाहिए (जैसे
H4 S8) - कार्ड के नाम और सूचकांक को आउटपुट में मिलाया जा सकता है (उदाहरण के लिए
0 H7 3 D3) - ट्रेलिंग और अग्रणी स्थानों की अनुमति है।
- खिलाड़ी द्वारा उपरोक्त आउटपुट के परिणामस्वरूप इनपुट को
bot.jlscफ़ाइल द्वारा निर्दिष्ट के रूप में स्वरूपित किया जाएगा , उसी क्रम में अनुरोध किया गया है
- कार्ड सूचकांकों को उनके बीच कम से कम एक स्थान के साथ आउटपुट होना चाहिए (जैसे
- एक खिलाड़ी जो अपने हाथ जोड़ना चाहता है, उसमें अग्रणी और अनुगामी स्थान हो सकते हैं।
- हाथों को उनके बीच कम से कम एक स्थान के साथ आउटपुट होना चाहिए (उदाहरण के लिए
H4 D5 CA), अनुगामी स्थान और अग्रणी स्थान की अनुमति है। - हाथों को उचित क्रम में उत्पादन करने की आवश्यकता नहीं है (उदाहरण के लिए
H4 D4 C4 DA SAऔरH4 DA D4 SA C4दोनों 4, 4, 4, ऐस, ऐस का प्रतिनिधित्व करते हैं, जो एक पूर्ण घर है)। - यदि आप विरोधियों के हाथों का विश्लेषण करके रणनीति बनाना चाहते हैं, तो आप किसी
<botname>/dataनिर्देशिका में डेटा संग्रहीत कर सकते हैं ।- प्रतिस्पर्धा करने के बाद बॉट्स ने अपने हाथों को प्रदर्शित किया है, वे प्रत्येक बॉट डेटा डायरेक्टरी को हैंड्सटेक्स्ट में लिखे जाएंगे, जिसमें प्रत्येक हाथ एक नई लाइन (\ n द्वारा अलग) पर होगा। फ़ाइल को US_ASCII में एन्कोड किया जाएगा।
- आपके बॉट द्वारा नए कार्ड या विनिमय कार्ड का अनुरोध करने के बाद, कार्ड आपके द्वारा
bot.jlscफ़ाइल में निर्दिष्ट किए गए प्रारूप के आधार पर इनपुट होंगे ।
पोस्ट प्रारूप
- हर पोस्ट में दो चीजें शामिल होनी चाहिए:
- आपके बॉट का स्रोत कोड, या रिपॉजिटरी का सामना करने वाली जनता के लिए एक लिंक।
- युक्त ज़िप फ़ाइल:
- आपके बॉट का संकलित / निष्पादन योग्य संस्करण (यदि फ़ाइल एक .exe या अन्य गैर-डी-संकलन योग्य फ़ाइल है, तो कृपया अपने पोस्ट में संकलन निर्देश शामिल करें)।
- एक
bot.jlscफ़ाइल, नीचे देखें (साइड नोट: .jlsc एक्सटेंशन मेरा एक साइड प्रोजेक्ट की वजह से है, एक कॉन्फ़िगरेशन फॉर्मेट। नीचे दी गई फाइल उचित सिंटैक्स से मेल खाती है, इसलिए चिंता न करें)।
- .Zip फ़ाइल को आपके बॉट का नाम दिया जाना चाहिए।
- यदि आपके पास विंडोज़ या किसी अन्य ज़िपिंग उपयोगिता तक पहुंच नहीं है, या जो भी कारण से .zip नहीं कर सकते हैं, तो बस अपने पोस्ट में bot.jlsc फ़ाइल का पाठ शामिल करें
bot.jlsc फ़ाइल:
name= "Botty"
link= "example.com"
cmd= "java -jar Botty.jar"
input_hand= "${0} ${1} ${2} ${3} ${4}"
input_1= "${0}"
input_2= "${0} ${1}"
input_3= "${0} ${1} ${2}"
input_4= "${0} ${1} ${2} ${3}"
कहाँ पे:
- "cmd" आपके बॉट को चलाने के लिए विंडोज़ कमांड लाइन कमांड है। ध्यान दें कि आपका बॉट निर्देशिका में होगा
<botname>, इसलिए उसके अनुसार कमांड को समायोजित करें। - "नाम" आपके बॉट का नाम है।
- "लिंक" आपके उत्तर की लिंक है, पोस्ट करने के बाद आपको इसे संपादित करना होगा।
- "input_hand" यह है कि आप कैसे चाहते हैं कि मूल व्यवहार को स्वरूपित किया जाए ($ {#} कार्ड्स 0-4 का प्रतिनिधित्व करते हुए)।
- "input_1" आप एक अतिरिक्त कार्ड के इनपुट को प्रारूपित कैसे करना चाहते हैं।
- "input_2" यह है कि आप दो अतिरिक्त कार्डों के इनपुट को कैसे स्वरूपित करना चाहते हैं।
- "input_3" यह है कि आप तीन अतिरिक्त कार्डों के इनपुट को कैसे स्वरूपित करना चाहते हैं।
- "input_4" यह है कि आप कैसे चार अतिरिक्त कार्डों के इनपुट को स्वरूपित करना चाहते हैं।
विशिष्ट तथ्य
- इन खामियों को दूर किया जाता है (देखें 'आम नुकसान')
- आप एक बॉट नहीं लिख सकते हैं, हमेशा नियम सेट के भीतर, हर बार संभव सबसे अच्छा हाथ का उत्पादन करेगा। (यानी लंबे समय तक चलने वाले जानवर-बल के बॉट, लियोबॉट के रूप में कुछ भी 'अच्छा' नहीं होना चाहिए)
- आपका बॉट ~ 100 एमएस या उससे कम में चलना चाहिए (इस बिंदु पर अधिकतम, ~ 1 सेकंड की अधिकतम)
- अपने चुने हुए हाथ के बाद बॉट के किसी भी आउटपुट को अनदेखा किया जाएगा।
- मानक खामियों को अस्वीकार कर दिया जाता है।
- हां, मुझे पता है कि लिनक्स बेहतर है, लेकिन मेरे पास एक विंडोज़ पीसी है, इसलिए सुनिश्चित करें कि आपके प्रोग्राम का संकलित / निष्पादन योग्य संस्करण विंडोज़ कमांड लाइन से चलाया जा सकता है।
- मेरे पास पहले से ही मेरे कंप्यूटर पर अजगर और जावा स्थापित है, लेकिन मैं नए संस्करणों को अपडेट करने और अन्य वातावरणों को स्थापित करने के लिए तैयार हूं, इसलिए कृपया निर्दिष्ट करें कि आपके प्रोग्राम को किस प्रकार के वातावरण की आवश्यकता है।
- आप एक बॉट नहीं लिख सकते हैं जो हर मामले में दूसरे बॉट के समान काम करता है। स्पैम बॉट की अनुमति है, लेकिन हतोत्साहित किया गया।
- आपका बॉट केवल उसके पास मौजूद कार्ड का उपयोग कर सकता है। विनिमय के माध्यम से खो जाने वाले कार्ड या अंतिम हाथ में अमान्य आउटपुट के साथ शुरू करने के लिए निपटा नहीं।
- इनपुट और आउटपुट में केवल ASCII अक्षर हो सकते हैं।
प्रतियोगिता
- जब मुझे समय मिलेगा (मेरे कार्यक्रम लगभग लियो के रूप में पैक किए गए हैं, तो टूर्नामेंट चलाए जाएंगे, इसलिए यह थोड़ा संक्षिप्त है। असुविधा के लिए क्षमा करें।)।
- बॉट्स 4 व्यक्ति खेलों में प्रत्येक के खिलाफ गड्ढे होंगे, और बॉट्स के प्रत्येक संभावित सबसेट (यानी बहुत सारे खेल) के लिए एक गेम होगा।
- इस प्रक्रिया को पांच बार दोहराया जाएगा।
- जिस तरह से टूर्नामेंट हैंडलर बॉट्स के समूह बनाता है, उसी के अनुसार बॉट्स की संख्या को 4 से विभाज्य बनाने के लिए तीन भराव बॉट्स जोड़े जाएंगे। ये बॉट्स मूल रूप से निपटाए गए हाथों को वापस कर देंगे।
- हर राउंड और गेम के चलने के बाद, बॉट्स के स्कोर की गणना उनके द्वारा जीते गए गेम के आधार पर की जाएगी।
- कई बॉट एक स्थिति साझा कर सकते हैं (पहली पोस्ट द्वारा पहली बार जीते गए संबंध)।
- एक टूर्नामेंट खत्म होने के बाद, स्कोर को इस पोस्ट के निचले हिस्से में जोड़ा जाएगा।
स्कोरिंग
सामान्य KoTH नियम। सबसे गेम जीतने वाले बॉट (s) चुनौती जीतते हैं।
LeoBot
लियो का बॉट काफी स्मार्ट है। यह किसी भी कार्ड का आदान-प्रदान नहीं करता है, यह बहुत कठिन है, लेकिन यह अतिरिक्त कार्डों की अधिकतम संख्या का अनुरोध करता है, और यह सबसे अच्छा संभव हाथ निर्धारित करता है जो इसे बना सकता है, और उस हाथ को खेलता है। लेओबोट का मुख्य तर्क नीचे है।
package com.gmail.socraticphoenix.pokerface.leobot;
import com.gmail.socraticphoenix.pokerface.lib.card.Card;
import com.gmail.socraticphoenix.pokerface.lib.card.Deck;
import com.gmail.socraticphoenix.pokerface.lib.rule.HandRegistry;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class LeoBot {
public static void main(String[] args) {
List<Card> hand = new ArrayList<>();
Scanner scanner = new Scanner(System.in);
hand.addAll(Card.parseHand(scanner.nextLine()));
System.out.println(false);
System.out.println(3);
hand.addAll(Card.parseHand(scanner.nextLine()));
List<List<Card>> possibleHands = LeoBot.getSubsets(hand, 5);
System.out.println(Deck.toString(possibleHands.stream().sorted((a, b) -> HandRegistry.determineWinner(b, a).comparable()).findFirst().get()));
}
private static <T> void getSubsets(List<T> superSet, int k, int idx, List<T> current, List<List<T>> solution) {
if (current.size() == k) {
solution.add(new ArrayList<>(current));
return;
}
if (idx == superSet.size()) return;
T x = superSet.get(idx);
if (!current.contains(x)) {
current.add(x);
}
getSubsets(superSet, k, idx + 1, current, solution);
current.remove(x);
getSubsets(superSet, k, idx + 1, current, solution);
}
public static <T> List<List<T>> getSubsets(List<T> superSet, int k) {
List<List<T>> res = new ArrayList<>();
getSubsets(superSet, k, 0, new ArrayList<T>(), res);
return res;
}
}
ध्यान दें कि यदि लियोबॉट लगातार टूर्नामेंट जीतता है, और इसमें अच्छी मात्रा में प्रविष्टियाँ हैं, तो मैं दौड़ने में उसे शामिल करूँगा।
महत्वपूर्ण लिंक
अस्वीकरण
लियो और टेक इंक कहानी तत्व हैं और वास्तविक जीवन की कंपनियों या लोगों के लिए कोई समानता विशुद्ध रूप से अनजाने में है। (हालांकि, जब लियो की 'स्थिति' सवाल से शर्तों को जोड़ती या घटाती है, तो वे वास्तव में सवाल का हिस्सा होते हैं ...)
1
@ लोकतान्त्रिक मैं अत्यधिक इसे अब या कभी नहीं करने की सलाह दूंगा। जमा करने के बाद स्कोरिंग को समायोजित करना खिलाड़ियों के लिए वास्तव में अनुचित होगा।
—
नाथन मेरिल
@DestructibleWatermelon बेहतर है? सिर्फ FYI करें, यह 2-3 दिनों के लिए सैंडबॉक्स पर था ... किसी ने टिप्पणी नहीं की। मेरा मतलब है, यह सब शांत है
—
सुकराती फीनिक्स
इसके अलावा, @NathanMerrill शायद अभी भी गूंगा बॉट जीतने के बारे में सही है। Cjam somwhat की जांच के बाद, 5 बाइट प्रोग्राम
—
विनाशकारी नींबू
"f"q+न्यूनतम आवश्यकताओं को पूरा करता है। यदि प्रतियोगिता में 10 लोग हैं, तो यह संभवतः सभी गैर-गूंगा प्रविष्टियों (गैर-गूंगा प्रविष्टि में>> 75 वर्ण, 5 * 10 (डम बॉट का स्कोर, अंतिम आ रहा है) = 50 <75 है (बहुत छोटे स्मार्ट बॉट का स्कोर) (पहले आ रहा है)))। इस प्रकार, आपको शायद इस चुनौती से कोडगुल्फ को हटा देना चाहिए
यहां तक कि अगर Cjam का उपयोग नहीं किया जा सकता है, तो बिंदु खड़ा है कि डंबबोट एक उचित रणनीति होगी, और कोडगुल्फ़ को हटाने से आकार संतुलन की सभी कठिनाइयों को दूर किया जाएगा वीएस प्रदर्शन
—
विनाशकारी नींबू
कोड-गोल्फ को मौत के घाट
—
उतार दिया