लीडरबोर्ड
154 Calculator
144 Taxman
138 Statistician
137 Solver
137 RandoAggroLawyer
136 Gambler
134 Turncoat
119 Lawyer
119 BloodyMurder
113 Bandit
79 Challenger
74 Mask
64 Random
लॉग और सभी आउटपुट फ़ाइलों सहित नवीनतम मैच का एक संग्रह उपलब्ध है।
कैलक्यूलेटर, Brilliand द्वारा, विजेता है! उसका जवाब स्वीकार किया जाता है, लेकिन इसका मतलब यह नहीं है कि चुनौती खत्म हो गई है। नई प्रविष्टियों को प्रस्तुत करने या अपने वर्तमान को संपादित करने के लिए स्वतंत्र महसूस करें और उसे अपने सिंहासन से हटाने की कोशिश करें। मैं महीने के अंत में नेता को एक इनाम दूंगा।
खेलने के नियम
तख्तापलट 2-6 खिलाड़ियों के लिए बनाया गया एक कार्ड गेम है, जिसे हम दो के साथ खेलेंगे। इसमें सिक्कों का खजाना (हमारे उद्देश्यों के लिए अनंत) और 15 कार्डों का एक डेक होता है, जिसमें निम्न में से प्रत्येक प्रकार के 3 होते हैं: राजदूत, हत्यारा, कप्तान, कोंटेसा, ड्यूक। खेल की शुरुआत में, प्रत्येक खिलाड़ी को एक सिक्का दिया जाता है और यादृच्छिक पर दो कार्ड निपटाए जाते हैं, जिसे वे आवश्यक होने तक गुप्त रखते हैं। ऑब्जेक्ट आपके हाथ में कार्ड के साथ अंतिम खिलाड़ी होना है।
अपनी बारी पर, एक खिलाड़ी अपने कार्ड की परवाह किए बिना निम्नलिखित में से एक कार्रवाई कर सकता है:
- आय: राजकोष से 1 सिक्का लें। अनब्लॉक और अनचाहे।
- विदेशी सहायता: खजाने से 2 सिक्के लें। एक ड्यूक के साथ एक खिलाड़ी द्वारा अवरुद्ध किया जा सकता है। असहनीय।
- तख्तापलट: खेलने से अपनी पसंद के एक प्रतिद्वंद्वी का एक कार्ड निकालें। लागत 7 सिक्के। पीड़ित कार्ड को छोड़ने के लिए चुन सकता है। यदि किसी खिलाड़ी के पास अपनी पारी की शुरुआत में 10 या अधिक सिक्के हैं, तो उन्हें तख्तापलट करना होगा । अनब्लॉक और अनचाहे।
उनके कार्ड के आधार पर, खिलाड़ी अपनी बारी के रूप में निम्नलिखित में से एक कार्रवाई भी कर सकते हैं:
- विनिमय: एक राजदूत के साथ एक खिलाड़ी डेक से दो कार्ड ले सकता है। फिर वे अपने हाथ और खींचे गए कार्ड से उतने कार्ड चुन सकते हैं, जितने मूल रूप से उनके पास थे। (यही है, अगर उनके पास केवल एक कार्ड था, तो वे इसे तैयार किए गए कार्डों में से एक के लिए विनिमय कर सकते हैं या इसे रख सकते हैं, और यदि उनके पास दो कार्ड हैं, तो वे चार में से किन्हीं दो कार्डों को चुन सकते हैं।) दो अवांछित कार्ड डेक पर वापस आ जाते हैं। । अस्वीकार्य, लेकिन चुनौतीपूर्ण।
- हत्या: एक हत्यारे के साथ एक खिलाड़ी खेल से एक प्रतिद्वंद्वी के कार्ड को हटाने के लिए 3 सिक्के खर्च कर सकता है। पीड़ित कार्ड को छोड़ने के लिए चुन सकता है। एक कॉन्टेसा वाले खिलाड़ी द्वारा अवरुद्ध किया जा सकता है, जिस स्थिति में सिक्के वापस नहीं किए जाते हैं। चुनौतीपूर्ण, जिस स्थिति में सिक्के वापस आ जाते हैं ।
- चोरी: एक कप्तान के साथ एक खिलाड़ी अपने प्रतिद्वंद्वी से दो सिक्के ले सकता है। यदि प्रतिद्वंद्वी के पास एक सिक्का है, तो वे उस एक सिक्के को ले लेंगे। यदि प्रतिद्वंद्वी के पास शून्य सिक्के हैं, तो वे चोरी नहीं कर सकते। एक एंबेसडर या एक कप्तान के साथ एक खिलाड़ी द्वारा अवरुद्ध किया जा सकता है। Challengeable।
- कर: ड्यूक वाला खिलाड़ी खजाने से 3 सिक्के ले सकता है। अस्वीकार्य, लेकिन चुनौतीपूर्ण।
तख्तापलट का मुश्किल हिस्सा यह है कि खिलाड़ियों को झूठ बोलने की अनुमति है कि उनके पास क्या कार्ड है! किसी के पास कार्रवाई करने या उसके साथ जुड़े ब्लॉक को करने का प्रयास करने के लिए कार्ड नहीं है।
जब कोई खिलाड़ी कार्ड की कार्रवाई करता है, तो कोई भी प्रतिद्वंद्वी (यहां तक कि उस कार्रवाई से कोई नुकसान नहीं होता है) अभिनेता को चुनौती दे सकता है और कह सकता है कि उन्हें विश्वास नहीं है कि उनके पास उस कार्रवाई के लिए कार्ड है। यदि चैलेंजर सही है, तो कार्रवाई रद्द कर दी जाती है और अभिनेता को अपनी पसंद का एक कार्ड छोड़ना चाहिए (यदि लागू हो तो उन्हें खर्च किए गए किसी भी सिक्के को वापस लेना)। यदि नहीं, तो कार्रवाई की जाती है, अभिनेता डेक के बारे में चुनौती दी गई कार्ड वापस कर देता है और एक नया ड्रॉ करता है, और चुनौती देने वाले को अपने कार्ड में से एक को छोड़ देना चाहिए। खिलाड़ियों को इस बात पर सच्चाई होनी चाहिए कि चुनौती देने पर वे क्या कार्ड रखते हैं।
हत्यारे, तख्तापलट, और खो चुनौतियों के साथ ताश के पत्तों को समाप्त करने के लिए डेक पर वापस नहीं किया जाता है, लेकिन एक विजयी चुनौती के हिस्से के रूप में प्रकट किए गए कार्ड डेक पर वापस आ जाते हैं।
कार्यों की तरह ही ब्लॉक को चुनौती दी जा सकती है। उदाहरण के लिए, यदि खिलाड़ी A दावा करता है कि विदेशी सहायता और खिलाड़ी B कहता है "मेरे पास एक ड्यूक है और मैं आपके विदेशी सहायता को अवरुद्ध करता हूं", A कह सकता है "मुझे विश्वास नहीं है कि आपके पास ड्यूक है।" यदि वह दावा सही है, तो B झूठ में पकड़े जाने के लिए एक कार्ड खो देता है और A 2 सिक्के लेता है; यदि ऐसा नहीं है, तो ए कार्ड खो देता है और कोई सिक्के नहीं मिलते हैं, और बी को अपने ड्यूक को डेक पर लौटना चाहिए और एक नया कार्ड बनाना चाहिए।
जिस तरह से ब्लॉक और चुनौतियां Assassinate के साथ काम करती हैं, उसे दूर करना चाहिए। मान लीजिए कि खिलाड़ी A कहता है "मेरे पास एक हत्यारा है, और मैं एक खिलाड़ी की हत्या करता हूं"। यदि B, A को चुनौती देने या ब्लॉक करने का प्रयास नहीं करता है, तो हत्या हो जाती है: B एक कार्ड खो देता है और A 3 सिक्कों का भुगतान करता है।
वैकल्पिक रूप से, B यह कहकर चुनौती दे सकता है कि "मुझे विश्वास नहीं है कि आपके पास एक हत्यारा है"। यदि यह सच है, तो A कार्ड को त्याग देता है और उनके सिक्के वापस कर दिए जाते हैं, जबकि B अप्रभावित रहता है, और A की बारी समाप्त हो जाती है। यदि B का विश्वास गलत है और A एक हत्यारे को पकड़ता है, तो B अपने दोनों पत्ते खो देता है और असफल हो जाता है, एक गलत चुनौती के लिए और एक हत्यारे से।
चुनौती देने के बजाय, बी कह सकता है "मेरे पास एक कॉनसेसा है, और मैं हत्या को अवरुद्ध करता हूं"। अगर A, B को मानता है, तो A की बारी समाप्त हो जाती है और उनके सिक्के वापस नहीं मिलते हैं। लेकिन A ब्लॉक को चुनौती दे सकता है और कह सकता है "मुझे विश्वास नहीं है कि आपके पास एक Contessa है।" यदि B वास्तव में एक Contessa पकड़ता है, तो A गलत चुनौती के लिए एक कार्ड खो देता है। लेकिन अगर बी नहीं करता है, तो बी एक झूठ में पकड़े जाने के लिए एक कार्ड खो देता है और दूसरे हत्या से।
उपरोक्त स्पष्टीकरण के समान तर्क कैप्टन की चोरी करने की क्षमता पर लागू होता है, जहां या तो कार्रवाई या ब्लॉक को चुनौती दी जा सकती है।
आपके दोनों कार्डों को खोना और एक बारी में समाप्त करना संभव है, यदि आप एक हत्यारे को असफल चुनौती देते हैं या आप एक हत्यारे को ब्लॉक करने के लिए एक Contessa के होने का दावा करते हुए गलत तरीके से पकड़े जाते हैं। आप चुनौती से एक कार्ड और हत्या से एक कार्ड खो देते हैं।
चुनौती
आपका कार्य एक प्रोग्राम लिखना है जो कूप खेलेंगे। इसे इसकी कमांड लाइन तर्क के रूप में दिया जाएगा:
- एक फ़ाइल का नाम जिसमें उसके और उसके विरोधियों के कार्यों की सूची है।
- प्रतिद्वंद्वी के सिक्के की गिनती का संकेत करते हुए 0 से 12 तक का पूर्णांक।
- 0 से 12 तक के पूर्णांक में इसका सिक्का गिनती दर्शाता है।
- एक से चार वर्णों तक का एक तार जो उसके कार्ड को दर्शाता है। आम तौर पर यह आपके प्रोग्राम का एक या दो कार्ड होगा, लेकिन यदि आपका प्रोग्राम अभी एक्सचेंज में सफल हुआ है, तो यह n + 2 अक्षर लंबा होगा, जहाँ n आपके कार्ड की संख्या शेष है। आपका प्रोग्राम तब n कार्ड को आउटपुट करता है जिसे वह STDOUT पर रखना चाहता है। (इस उद्देश्य के लिए प्रोग्राम को पढ़ने या एक्सेस करने की ज़रूरत नहीं है - यदि आप डिबग आउटपुट का उत्पादन करना चाहते हैं, तो कृपया STDRR को लिखें।)
- एक या एक से अधिक तर्क यह बताते हैं कि कानूनी चालें चल सकती हैं।
(उदाहरण के आह्वान: yourprogram file.txt 1 7 '~!' a c p qजिसका अर्थ है "आपके प्रतिद्वंद्वी के पास 1 सिक्का है। आपके पास 7 सिक्के, एक राजदूत और एक कंटैसा है। खेल इतिहास और वर्तमान गेम स्थिति को देखते हुए, अपनी पसंद की फ़ाइल, c, p, या q को लिखें। ")
आपके कार्यक्रम को एक या (दो विशिष्ट स्थितियों में) दो पात्रों को प्रदान करना होगा जो प्रदान की गई फ़ाइल में दो अक्षर इसकी क्रिया को दर्शाते हैं। यह अन्यथा फ़ाइल की मौजूदा सामग्री को बदलना नहीं चाहिए। यह अपनी इच्छानुसार कोई भी नई फ़ाइल बना सकता है, लेकिन केवल उस निर्देशिका के भीतर, जिसमें इसे चलाया जाता है। कृपया अपने कार्यक्रम को संकलित करने और चलाने के लिए सभी आवश्यक आदेश प्रदान करें।
मैंने नीचे दो उदाहरण प्रतिस्पर्धी प्रदान किए हैं, जो गो में लिखे गए हैं।
आउटपुट स्वरूप है:
I\n: आय। कानूनी प्रतिक्रियाएं: कोई भी मोड़ कार्रवाई (यह मानकर कि उसके पास हत्यारे / तख्तापलट के लिए सिक्के हैं)।F: विदेशी सहायता। कानूनी प्रतिक्रियाएं:d(ड्यूक के रूप में ब्लॉक करें),p(इसे पास होने दें)।C: तख्तापलट। कानूनी प्रतिक्रियाएं: जो भी की_,',<,=,0अपने हाथ में है।E: अदला बदली। कानूनी प्रतिक्रियाएं:q(चुनौती, विश्वास नहीं है कि खिलाड़ी के पास एक राजदूत है)p,।T: कर। कानूनी प्रतिक्रियाएं:q(चुनौती, खिलाड़ी पर विश्वास नहीं करना एक ड्यूक है)p,।A: हत्या करना। कानूनी प्रतिक्रियाएं:s(क Contessa के रूप में ब्लॉक),q(चुनौती), और जो भी की_,',<,=,0अपने हाथ में है।S: चोरी करना। कानूनी प्रतिक्रियाएँ:a(एक राजदूत के रूप में ब्लॉक),c(एक कप्तान के रूप में ब्लॉक),q(चुनौती, विश्वास नहीं है कि एक कप्तान है)p,।d: ड्यूक के रूप में फॉरेन एड को ब्लॉक करें। कानूनी प्रतिक्रियाएं:\n(ब्लॉक को स्वीकार करें),q(चुनौती, विश्वास नहीं करना खिलाड़ी के पास ड्यूक है)।a: एक राजदूत के रूप में एक चोरी को रोकें। कानूनी प्रतिक्रियाएं:\n(ब्लॉक को स्वीकार करें),q(चुनौती, विश्वास नहीं करना खिलाड़ी का एक राजदूत है)।c: एक कप्तान के रूप में एक चोरी को रोकना।\n(ब्लॉक स्वीकार करें),q(चुनौती, विश्वास नहीं है कि खिलाड़ी के पास एक कप्तान है)।s: एक हत्यारे को एक कॉनसेन के रूप में ब्लॉक करें। कानूनी प्रतिक्रियाएं:\n(ब्लॉक को स्वीकार करें),q(चुनौती, विश्वास नहीं करते कि खिलाड़ी के पास एक कंटैसा है)।p: जब आपकी बारी न हो तो एक्सचेंज / टैक्स / चोरी को चुनौती देना। के साथ प्रयोग नहीं किया गयाA; एक चुनौती लिखने के लिए अस्वीकार करने के लिए_'<=0। कानूनी प्रतिक्रिया:\n(अपनी बारी समाप्त करें), और अगर आप अभी-अभी एक्सचेंज में सफल हुए हैं, तो उन कार्डों को लिखें जिन्हें आप चौथी कमांड लाइन तर्क से एसटीडीयूएस में रखना चाहते हैं।q: सबसे हाल की कार्रवाई या ब्लॉक को चुनौती दें। कानूनी प्रतिक्रिया: यदि आपके पास चुनौती दी गई कार्रवाई के लिए कार्ड है, जो भी~^*!$था। यदि आप नहीं करते हैं, तो_'<=0आपके हाथ में से जो भी आप छोड़ना चाहते हैं, उसके बाद एक नया और यदि केवल आपकी बारी है।~,^,*,!,$: पता चलता है कि आप Exchange में पकड़े, क्रमशः, एक राजदूत, एक हत्यारा, एक कप्तान, एक Contessa, और एक ड्यूक (भी आदेश पंक्ति तर्क में इन कार्डों का प्रतिनिधित्व करते थे, और STDOUT उत्पादन के बारे में सच कह रहे थे )। कानूनी प्रतिक्रियाएं: जो भी की_,',<,=,0आप अपने हाथ में है।_,',<,=,0: अप सजा के रूप में क्रमश: एक राजदूत, और हत्यारा, एक कप्तान, एक Contessa, और एक ड्यूक देते हैं, क्योंकि आप एक चुनौती खो दिया है या / Couped हत्या कर रहे थे। कानूनी प्रतिक्रिया:\n।\n: यदि लागू हो तो किसी ब्लॉक को चुनौती देने के लिए ऐसा करने में अपनी बारी समाप्त करें। कानूनी प्रतिक्रियाएं: कोई भी पूंजी-पत्र कार्रवाई (मान लें कि किसी के पास हत्यारे / तख्तापलट के लिए सिक्के हैं और प्रतिद्वंद्वी के पास चोरी के लिए सिक्के हैं)।
प्रारूप में निम्नलिखित उपयोगी गुण हैं:
- मोड़ एक बड़े अक्षर से शुरू होते हैं।
- रेखाएँ पैटर्न का अनुसरण करती हैं: अपरकेस लेटर, लोअरकेस अक्षर, वैकल्पिक रूप से विराम चिह्न या सामने आए कार्ड के लिए 0, न्यूलाइन।
- एक नई लाइन, या एक खाली फ़ाइल के साथ समाप्त होने वाली फ़ाइल इंगित करती है कि यह आपके प्रोग्राम की शुरुआत है और इसे एक कैपिटल लेटर एक्शन चुनना होगा।
- आम तौर पर एक आह्वान पर आपको जिन कानूनी कार्रवाइयों की अनुमति दी जाती है, वे आमतौर पर फ़ाइल में अंतिम चरित्र द्वारा निर्धारित की जाती हैं। अपवाद है
q, जिसके साथ कुछ तर्क जुड़े होंगे।get_legal_actionsइसे समझने में मदद करने के लिए आर्बिटर में फ़ंक्शन देखें । या आप कमांड लाइन पर दिए गए कानूनी कार्यों का उपयोग कर सकते हैं। - एक पंक्ति में वर्णों की संख्या भी बताती है कि बारी आपकी है और आपके कार्यक्रम को एक कार्रवाई चुनने, ब्लॉक को चुनौती देने या अपनी बारी को समाप्त करने के लिए कहा जाता है।
- एक पंक्ति में विषम संख्या में वर्ण यह दर्शाते हैं कि बारी आपकी नहीं है और आपके कार्यक्रम को कार्ड को ब्लॉक करने, चुनौती देने या प्रकट करने / आत्मसमर्पण करने के लिए कहा गया है।
मैं हर कार्रवाई के लिए एक उदाहरण दूंगा।
I\nसमझने में सबसे आसान है। एक कार्यक्रम आय का एक सिक्का लेता है, फिर अपनी बारी समाप्त करता है। यह उन दो मामलों में से एक है जहां कार्यक्रमों को दो वर्णों को मुद्रित करना चाहिए, क्योंकि आय एकमात्र ऐसी कार्रवाई है जहां प्रतिद्वंद्वी दोनों अप्रभावित हैं और ब्लॉक या चुनौती नहीं दे सकते हैं।
Fp\nइसका मतलब है कि एक कार्यक्रम में विदेशी सहायता ली गई, फिर उसके प्रतिद्वंद्वी ने ब्लॉक ( p) में गिरावट की । इसके अगले आह्वान पर, पहले कार्यक्रम ने नोट किया कि अंतिम लोअरकेस pऔर / या इस लाइन पर वर्णों की संख्या ने इस मोड़ को ले लिया, जो अभी तक समाप्त नहीं हुआ है, इसलिए यह एक नई लाइन प्रिंट करके अपने वर्तमान मोड़ को समाप्त करना जानता है।
C=\nइसका मतलब है कि एक कार्यक्रम ने एक कूप का शुभारंभ किया। इसके प्रतिद्वंद्वी, यह जानकर कि इसे लाइन पर अक्षरों की विषम संख्या से प्रतिक्रिया करने के लिए बुलाया गया था, ने एक कंटैसा छोड़ दिया। फिर से, पहले कार्यक्रम को पता था कि यह लाइन पर वर्णों की संख्या द्वारा अपने अगले आह्वान पर अपनी अपूर्ण बारी थी, इसलिए इसने अपनी बारी को समाप्त करने के लिए एक नई पंक्ति लिखी।
Eq~<\nइसका मतलब यह होगा कि एक कार्यक्रम ने एक्सचेंज ( E) और उसके प्रतिद्वंद्वी को चुनौती दी ( q)। आदान-प्रदान कार्यक्रम से पता चला कि यह सच में एक राजदूत ( ~) था और चुनौती देने वाले ने एक कप्तान को सजा ( <) के रूप में दिया था । चैलेंजर से बाहर निकलने के बाद, एक्सचेंजिंग प्रोग्राम को चार-वर्ण स्ट्रिंग के साथ फिर से चौथी कमांड लाइन तर्क (या तीन वर्ण, यदि इसमें केवल एक कार्ड होता है) के साथ लागू किया जाता है। यह उन पात्रों का प्रतिनिधित्व करता है जो कार्ड का प्रतिनिधित्व करना चाहते हैं जो एसटीडीयूएसटी को रखना चाहते हैं और फ़ाइल को एक नई रेखा।
Tq'\nइसका मतलब है कि एक कार्यक्रम ने एक असत्य कर का प्रयास किया, चुनौती दी गई, और एक हत्यारे को छोड़ दिया। यह दूसरे मामले को दिखाता है जहां दो अक्षर लिखे गए हैं: यदि आपकी बारी है और आपको कार्ड छोड़ने के लिए मजबूर किया जाता है - या तो एक प्रतिद्वंद्वी की सही चुनौती से (जैसा कि यहां) या आपके ब्लॉक की गलत चुनौती से - तो आपको दोनों लिखना होगा कार्ड जो आप छोड़ देते हैं और अपनी बारी खत्म करने के लिए एक नई लाइन।
Asq!'\nइसका मतलब यह होगा कि खिलाड़ी बी ने खिलाड़ी ए ( A) को मारने का प्रयास किया था , लेकिन ए ने इसे अवरुद्ध करने के लिए एक कॉनसेसा होने का दावा किया ( s)। B ने A को नहीं माना और चुनौती दी ( q)। एक तथ्य यह है कि उन्होंने किया था, वास्तव में, एक Contessa ( !) है। बी ने एक हत्यारे को सजा के रूप में छोड़ दिया, अपने सिक्कों को खो दिया, और अपनी बारी को समाप्त कर दिया ( '\n), उस विशेष मामले में दो पात्रों को लिखना। (यदि =मैंने इसे ब्लॉक या चुनौती नहीं देने का फैसला किया था, तो यह लिखा जा सकता था , और तब इसके प्रतिद्वंद्वी ने देखा होगा कि टर्न खत्म हो गया है और एक नई लाइन लिखी गई है। लाइन फिर A=\nकूप उदाहरण की तरह पढ़ी जाएगी ।)
Sq*0\nइसका मतलब है कि एक कार्यक्रम एक चोरी का प्रयास करता है; प्रतिद्वंद्वी को चुनौती, विश्वास नहीं चोर एक कप्तान है; और मूल कार्यक्रम में एक कप्तान का पता चलता है, इसलिए चुनौती असफल है और चुनौती देने वाले को सजा के रूप में ड्यूक देता है। (इसके प्रतिद्वंद्वी के लिए एक और विकल्प होगा कि वह चोरी को लिखकर स्वीकार कर ले p। इसके प्रतिद्वंद्वी को अपनी बारी के अंत का पता लगाना होगा और लिखना होगा \n, जिसके परिणामस्वरूप एक पंक्ति होगी Sp\n)।
द आर्बिटर
इस पायथन लिपि से कार्यक्रम आमंत्रित किए जाएंगे। यह दस राउंड आयोजित करता है, जिसमें हर प्रतियोगी पहले और दूसरे दोनों स्थान पर जाते हुए हर दूसरे प्रतियोगी का सामना करता है। यह कार्डों और सिक्कों को ट्रैक करता है और दो बार विराम चिह्न के साथ एक पंक्ति को समाप्त करने के लिए पहले कार्यक्रम द्वारा हारने वाले को निर्धारित करता है। प्रोग्राम जो गैर-शून्य स्थिति के साथ बाहर निकलते हैं, फ़ाइल को संशोधित करते हैं, फ़ाइल पर एक अवैध कदम लिखते हैं, या एक अवैध एक्सचेंज का प्रयास करते हैं, स्वचालित रूप से जब्त हो जाएगा। यदि प्रत्येक खिलाड़ी 100 से अधिक कार्रवाई करता है, जिसमें ब्लॉक और चुनौतियां शामिल हैं, जिसमें कोई विजेता नहीं है, तो दोनों कार्यक्रम खो जाते हैं। एक विजेता को एक अंक दिया जाता है। जिस खिलाड़ी का कार्यक्रम सबसे अधिक अंक प्राप्त करता है वह जीतता है।
मेरा सुझाव है कि आप आर्बिटर के सोर्स कोड, विशेष रूप से get_legal_actionsफ़ंक्शन को पढ़ें । यह आपको विनिर्देश समझने और अपने स्वयं के कार्यक्रम लिखने में मदद कर सकता है।
import itertools
import os
import random
import subprocess
class Player:
def __init__(self, name, command):
self.name = name
self.command = command
self.score = 0
self.coins = 1
self.cards = ""
actions_dict = {
'E': '_', 'T': '0', 'A': "'", 'S': '<',
'd': '0', 'a': '_', 'c': '<', 's': '='
}
punishment_to_reveal = {'_': '~', "'": '^', '<': '*', '=': '!', '0': '$'}
reveal_to_punishment = {
punishment_to_reveal[k]: k for k in punishment_to_reveal
}
def get_legal_actions(history, player, opponent):
c = history[-1]
result = ""
# Our turn begins; choose an action.
if c == '\n':
if player.coins >= 10:
return ["C"]
ret = ['I\n'] + list("FET")
if player.coins >= 3:
ret.append("A")
if player.coins >= 7:
ret.append('C')
if opponent.coins > 0:
ret.append("S")
return ret
# Opponent attempted foreign aid; can pass or claim Duke to block.
elif c == 'F':
return list('dp')
# We have been Couped; must surrender a card.
elif c == 'C':
return player.cards
# We failed a challenge; must surrender a card and print a newline
# if it is our turn.
elif c in '~^*!$':
if history[-3] in 'acds':
return [card + '\n' for card in player.cards]
return player.cards
# Opponent attempted Exchange or Tax; can pass or challenge.
elif c == 'E' or c == 'T':
return list('pq')
# Opponent attempted an Assassination; can block, challenge, or give in.
elif c == 'A':
return list('sq') + player.cards
# Opponent attempted to Steal; can pass, block as Ambassador/Captain,
# or challenge.
elif c == 'S':
return list('acpq')
# Opponent blocked; can challenge or withdraw.
elif c in 'acds':
return list('q\n')
# Opponent passed on blocking Foreign Aid/Tax/Exchange or they gave up a
# card as punishment, must end turn.
elif c in "p_'<=0":
return ['\n']
# Opponent challenged us.
elif c == 'q':
challenged_action = history[-2]
# If we have the card they challenged us over, must reveal it.
necessary_card = actions_dict[challenged_action]
if necessary_card in player.cards:
return [punishment_to_reveal[necessary_card]]
# Otherwise, we can give up either of our cards, writing a newline
# if it is our turn.
if challenged_action in 'acds':
return list(player.cards)
else:
return [card + '\n' for card in player.cards]
else:
return None
deck = ['_', "'", '<', '=', '0'] * 3
random.shuffle(deck)
def determine_turn_effects(line, output, cards, current_player, opponent):
last_action = line[-2]
# Only operate if the opponent declined to challenge (p) or the
# program successfully challenged their block
if last_action in "p_'<=0":
primary_action = line[0]
# Foreign Aid
if primary_action == 'F':
print current_player.name, "received 2 coins of Foreign Aid"
current_player.coins += 2
# Tax
elif primary_action == 'T':
print current_player.name, "received 3 coins of Tax"
current_player.coins += 3
# Steal
elif primary_action == 'S':
stolen_coins = 1 if opponent.coins == 1 else 2
print current_player.name,\
"stole %d coins from %s" % (stolen_coins, opponent.name)
current_player.coins += stolen_coins
opponent.coins -= stolen_coins
# Exchange, store desired cards and replace undesired ones
elif primary_action == 'E':
print current_player.name, "tried to take %r" % output, "from", cards
legal_outputs = [''.join(p) for p in itertools.permutations(
cards, len(current_player.cards))]
if output not in legal_outputs:
print current_player.name, "forfeits by illegal exchange"
return opponent
current_player.cards = [
reveal_to_punishment[c] for c in output
]
undesired_cards = list(cards)
for c in output:
undesired_cards.remove(c)
for card in undesired_cards:
deck.append(reveal_to_punishment[card])
random.shuffle(deck)
# Coins are not returned from a successful Contessa block
elif last_action == 's':
print current_player.name, "lost 3 coins from a Contessa block"
current_player.coins -= 3
return None
def play_game(player1, player2, round_number, game_number):
outfilename = os.path.abspath(__file__)[:-len(__file__)] + '_'.join([
player1.name, player2.name, str(round_number), str(game_number)
]) + '.txt'
print outfilename
f = open(outfilename, 'w')
f.close()
players_list = [player1, player2]
player1.cards = [deck.pop(), deck.pop()]
player2.cards = [deck.pop(), deck.pop()]
current_player_index = 0
for i in range(200):
current_player = players_list[current_player_index]
opponent = players_list[(current_player_index+1) % 2]
legal_actions = []
original_contents = []
original_contents_joined = ""
with open(outfilename, 'r') as outfile:
original_contents = outfile.readlines()
original_contents_joined = ''.join(original_contents)
if len(original_contents) == 0:
legal_actions = ['I\n'] + list("FEST")
else:
legal_actions = get_legal_actions(
original_contents[-1], current_player, opponent)
if not legal_actions:
print "Error: file ended in invalid character"
return current_player
# Has the player completed an Exchange? Pass them new cards if so.
exchange_cards = ""
old_last_line = original_contents[-1] if len(original_contents) > 0 else '\n'
if old_last_line[-1] != '\n' and old_last_line[0] == 'E' and \
len(old_last_line) % 2 == 0 and old_last_line[-1] in "p_'<=0":
exchange_cards = punishment_to_reveal[deck.pop()] + \
punishment_to_reveal[deck.pop()]
cards = exchange_cards + ''.join(
punishment_to_reveal[card] for card in current_player.cards)
args = current_player.command + [
outfilename,
str(opponent.coins),
str(current_player.coins),
cards
] + legal_actions
print ' '.join(args)
output = ""
os.chdir(current_player.name)
try:
output = subprocess.check_output(args)
# Competitors that fail to execute must forfeit
except subprocess.CalledProcessError:
print current_player.name, "forfeits by non-zero exit status"
return opponent
finally:
os.chdir('..')
new_contents = []
new_contents_joined = ""
with open(outfilename, 'r') as outfile:
new_contents = outfile.readlines()
new_contents_joined = ''.join(new_contents)
if original_contents_joined != new_contents_joined[:-2] and \
original_contents_joined != new_contents_joined[:-1]:
print current_player.name, "forfeits by modifying the file"
print "old:", original_contents
print "new:", new_contents
return opponent
new_last_line = new_contents[-1]
the_move_made = ""
for action in legal_actions:
if new_last_line.endswith(action):
the_move_made = action
break
# Competitors that make an illegal move must forfeit
if not the_move_made:
print current_player.name, "forfeits with an illegal move,",\
"last line: %r" % new_last_line
print opponent.name, "wins!"
return opponent
print current_player.name, "played %r" % the_move_made
# Side effects of moves.
#
# Income, give the current player a coin.
if the_move_made == "I\n":
print current_player.name, "received 1 coin of income"
current_player.coins += 1
# The program surrendered a card on its turn; take it away.
elif len(the_move_made) == 2:
print current_player.name, "lost a card from being challenged"
current_player.cards.remove(the_move_made[0])
# Coins are not returned from a successful Contessa block
if new_last_line[-3] == '!':
print current_player.name, "lost 3 coins from a Contessa block"
current_player.coins -= 3
# The program surrendered a card when it was not its turn.
elif the_move_made in "_'<=0":
print current_player.name, "gave up a", the_move_made
current_player.cards.remove(the_move_made)
if new_last_line[0] == 'C':
opponent.coins -= 7
elif new_last_line[0] == 'A':
opponent.coins -= 3
# Did the program unsuccessfully challenge an Assassination
# (e.g. Aq^0\n)
# or get caught falsely blocking with a Contessa
# (e.g. Asq0\n)?
# If yes, it loses right away.
if new_last_line[0] == 'A' and new_last_line[1] in 'qs' and \
len(new_last_line) == 4:
print current_player.name, "lost both cards in the same turn."
print opponent.name, "wins!"
return opponent
elif the_move_made == 'S':
print current_player.name, "attempted Steal"
elif the_move_made == 'T':
print current_player.name, "attempted Tax"
elif the_move_made == 'A':
print current_player.name, "attempted Assassinate"
elif the_move_made == 'C':
print current_player.name, "launched a Coup"
elif the_move_made == 'F':
print current_player.name, "attempted Foreign Aid"
elif the_move_made == 'E':
print current_player.name, "attempted Exchange"
elif the_move_made == 'q':
print current_player.name, "challenged"
elif the_move_made == 'p':
print current_player.name, "passed"
elif the_move_made == 'a':
print current_player.name, "blocked with an Ambassador"
elif the_move_made == 'c':
print current_player.name, "blocked with a Captain"
elif the_move_made == 's':
print current_player.name, "blocked with a Contessa"
elif the_move_made == 'd':
print current_player.name, "blocked with a Duke"
# The program revealed a card from an opponent's unsuccessful challenge.
# Give it a new card.
# Special case: a program whose Exchange is unsuccessfully challenged
# may keep the Ambassador it revealed in the Exchange, so give a new
# card for a revealed Ambassador only if it was used to block a Steal.
elif the_move_made in '^*!$' or (the_move_made == '~' and
new_last_line[0] == 'S'):
p = reveal_to_punishment[the_move_made]
current_player.cards.remove(p)
current_player.cards.append(deck.pop())
deck.append(p)
random.shuffle(deck)
print current_player.name, "did have a", the_move_made
# The program ended its turn. We must examine the rest of the line to
# determine the side effects.
elif the_move_made == '\n':
potential_winner = determine_turn_effects(
new_last_line, output.strip(), cards, current_player,
opponent)
if potential_winner:
print potential_winner.name,\
"wins because their opponent made an illegal exchange!"
return potential_winner
# One player has lost all their cards. Victory for the opponent!
if current_player.cards == []:
print opponent.name, "wins by eliminating both opponent cards!"
return opponent
current_player_index += 1
current_player_index %= 2
return None
competitors = []
competitors.append(Player("Challenger", ["./challenger"]))
competitors.append(Player("Random", ["./random"]))
# ...More competitors here
for i in range(10):
print "-- Round", i
j = 0
for pairing in itertools.permutations(competitors, 2):
player1, player2 = pairing
print '--- Game', j, ':', player1.name, 'vs.', player2.name
winner = play_game(player1, player2, i, j)
if not winner:
j += 1
continue
winner.score += 1
player1.coins = 1
player1.cards = ""
player2.coins = 1
player2.cards = ""
deck = ['_', "'", '<', '=', '0'] * 3
random.shuffle(deck)
j += 1
competitors.sort(reverse=True, key=lambda player: player.score)
for player in competitors:
print '%5d %s' % (player.score, player.name)
विविध
एक प्रोग्राम में दूसरे प्रोग्राम के लिए कोड विशिष्ट नहीं हो सकता है, और प्रोग्राम एक दूसरे की मदद नहीं कर सकते हैं। (आपके पास कई कार्यक्रम हो सकते हैं, लेकिन वे किसी भी तरह से एक दूसरे के साथ बातचीत नहीं कर सकते हैं।)
यदि आपका प्रोग्राम एक ही बारी में अपने दोनों कार्ड खो देता है, तो उसे केवल एक लिखने की आवश्यकता है। आर्बिटर यह पता लगाएगा कि इसे समाप्त कर दिया गया है।
फ़ाइल में गेम के इतिहास की जांच करने के लिए कार्यक्रमों के लिए यह संभव है और प्रोत्साहित किया गया है, लेकिन इसकी आवश्यकता नहीं है। ऐसा करके वे यह निर्धारित कर सकते हैं कि उनके प्रतिद्वंद्वी ने किस कार्ड को झूठ में पकड़ने और पकड़ने का दावा किया है।
तख्तापलट के असली खेल में, आप एक कार्रवाई को चुनौती दे सकते हैं और फिर उसी मोड़ में इसे अवरुद्ध करने का प्रयास कर सकते हैं। यदि मैंने अनुमति दी तो मैं विनिर्देश कार्य नहीं कर सकता था, इसलिए आप किसी दिए गए कार्य को चुनौती दे सकते हैं या ब्लॉक कर सकते हैं, लेकिन दोनों नहीं।
@PeterTaylor के लिए मेरी क्षमायाचना, जिसने पिछली बार मैंने यह सुझाव दिया था कि मैंने इसे सैंडबॉक्स में पोस्ट किया है और STDOUT / STDIN में आगे और पीछे आउटपुट के लिए प्रोटोकॉल को फिर से काम करता हूं। मैंने ऐसा प्रयास किया, इसलिए उस काम को करने के लिए बहुत मेहनत की, उस पर पूरा दिन बिताया (जब मैंने पहले से ही मूल चुनौती लिखने में पूरा दिन लगा दिया हो)। लेकिन एक्सचेंजों ने उस तरीके को लागू करने के लिए बहुत जटिल साबित कर दिया, साथ ही इससे उन्हें अपने स्वयं के सिक्के की गिनती का ट्रैक रखने के लिए आवश्यक आवश्यकताएं बढ़ गई। इसलिए मैंने चुनौती को कम से कम पोस्ट किया है क्योंकि यह मूल रूप से था।
S, बी लिखने से प्रोग्राम ब्लॉक होता है c, ए लिखने से चुनौती देने के लिए गिरावट आती है \n। एक चोरी की एक सफल चुनौती होगी: ए राइट S, बी चैलेंज बाय राइटिंग q, ए कॉन्सेप्ट बाय चैलेंज लिखकर जैसे _\n, आप एक्सचेंज सहित प्रति एक ही कार्रवाई कर सकते हैं। एक्सचेंज के लिए कानूनी प्रतिक्रियाएं पास और चुनौती हैं।