परम समुराई दिखावा

37

सूचना: इस राजा की पहाड़ी चुनौती पूरी हो गई है। इसका मतलब है कि हरे रंग की चेकमार्क, जो C5H8NNO4 को उनकी प्रविष्टि के लिए दी गई है, ऑब्जर्वर को किसी नए उत्तर में नहीं ले जाया जाएगा।

आप अभी भी नई प्रविष्टियाँ जमा कर सकते हैं, लेकिन नए टूर्नामेंटों में देरी हो सकती है क्योंकि मैं अब नई प्रविष्टियों के लिए सक्रिय रूप से जाँच नहीं कर रहा हूँ।

परिचय

इस चुनौती में, आप अंतिम आर्केड समुराई तसलीम अंतिम संस्करण विशेष संस्करण 2.0 एक्स अल्फा ओमेगा टर्बो (या संक्षेप में केवल अंतिम समुराई तसलीम ) शीर्षक से एक आर्केड खेल खेल रहे हैं । आपके विरोधी? प्रोग्रामिंग पहेलियाँ और कोड गोल्फ के अन्य सदस्यों के अलावा कोई नहीं!

जैसा कि आप PPCG आर्केड गेम से उम्मीद कर सकते हैं, आप सीधे अंतिम समुराई शोडाउन नहीं खेलते हैं, बल्कि एक प्रोग्राम लिखें जो आपके लिए गेम खेलेंगे। यह कार्यक्रम एक युगल में एक में अन्य उपयोगकर्ताओं द्वारा प्रस्तुत कार्यक्रमों के खिलाफ लड़ेगा। सबसे कुशल कार्यक्रम को PPCG के अंतिम समुराई का ताज पहनाया जाएगा, और उसे किंवदंती की हरी टिक प्रदान की जाएगी।

खेल विवरण

यह खंड खेल के पीछे यांत्रिकी का वर्णन करता है।

विजय की स्थिति

एक मैच में दो समुराई होते हैं जो एक दूसरे के खिलाफ सामना कर रहे हैं। प्रत्येक समुराई 20 हिट अंक और 1 सम्मान के साथ प्रत्येक मैच शुरू करता है । एक समुराई जीत जाता है यदि उसका प्रतिद्वंद्वी मर चुका है और वह अभी भी जीवित है। ऐसी दो विधियाँ हैं जिनसे समुराई मर सकता है:

  1. अगर समुराई के हिट पॉइंट्स को 0 पर लाया जाता है, तो वह मर जाएगा।
  2. यदि एक समुराई अपने स्वयं के सम्मान को 0 से नीचे लाता है , तो वह एक द्वंद्वयुद्ध में बेईमानी से काम करने के लिए देवताओं द्वारा मारा जाएगा।

देवताओं द्वारा मारा जाने के कारण 0 से कम हिट अंक होने पर उच्च प्राथमिकता है, इसलिए ऐसी स्थिति में जहां एक समुराई 0 स्वास्थ्य बिंदुओं पर है और दूसरा -1 सम्मान पर है, 0 स्वास्थ्य बिंदुओं वाला समुराई जीत जाएगा। ऐसी स्थिति में जहां दोनों समुराई -1 सम्मान पर हैं, वे दोनों देवताओं से टकरा जाते हैं और खेल एक ड्रा है।

एक मैच में 500 मोड़ तक होते हैं । यदि सभी 500 पास हो जाते हैं और मैच का फैसला नहीं किया गया है (न ही समुराई की मृत्यु हो गई है), तो देवता ऊब गए और दोनों समुराई पर हमला कर दिया, इस प्रकार ड्रॉ हुआ।

क्रिया

प्रत्येक मोड़ पर, समुराई को निम्न में से एक कार्रवाई करनी चाहिए:

W

समुराई प्रतीक्षा करेगा और कोई कार्रवाई नहीं करेगा। यह उसे शांत दिखता है लेकिन उसे अपने प्रतिद्वंद्वी को हराने में मदद नहीं करता है। यह भी डिफ़ॉल्ट क्रिया है।

B

समुराई अपने प्रतिद्वंद्वी को सम्मानजनक अंदाज में झुकाएंगे। यह देवताओं को प्रसन्न करता है और इस तरह समुराई 1 सम्मान हासिल करेगा। ऑनर आपके समुराई की सफलता के लिए महत्वपूर्ण है क्योंकि ऑनर अनिवार्य रूप से इस गेम के लिए "संसाधन" है - सभी अलग-अलग चलते हैं Bऔर Wऑनर को कम कर सकते हैं। इसके अलावा, अगर एक समुराई 7 सम्मान या अधिक हासिल करता है, तो उसे देवताओं की तलवार का उपयोग करने की अनुमति दी जाती है । इसके निहितार्थ नीचे वर्णित हैं।
हालांकि, आपके प्रतिद्वंद्वी को झुकना आपको खुला छोड़ देता है यदि आपका प्रतिद्वंद्वी आपको अपनी तलवार से मारने का फैसला करता है, तो जब आप झुकना चुनते हैं तो सावधान रहें।

G

समुराई एक रक्षात्मक स्थिति में प्रवेश करेगा और किसी भी तलवार हमले के खिलाफ रक्षा करेगा। यह कदम सभी तलवार हमलों को सफलतापूर्वक रोक देगा, यहां तक कि देवताओं की तलवार के साथ भी ।
हालांकि, देवताओं ने एक अत्यधिक रक्षात्मक समुराई पर हमला किया, इसलिए यह कदम 1 सम्मान का उपभोग करेगा अगर तत्काल पूर्ववर्ती मोड़ पर समुराई की कार्रवाई भी रखवाली कर रही थी। यह ऑनर का उपभोग नहीं करता है।

I

समुराई अपने विरोधी को अपनी तलवार से तेज़ तलवार से वार करने का प्रयास करेगा। यदि समुराई के पास 7 सम्मान या अधिक हैं, तो वह अपनी नियमित तलवार के बजाय देवताओं की तलवार का उपयोग करेगा । यह चाल 1 सम्मान की खपत करती है।
त्वरित ड्रॉ एक तेज़ स्ट्राइक है जो धीमी ओवरहेड हमलों को हरा देगा, हालांकि, यह पैरीज़ के खिलाफ हार जाएगा। हड़ताल कनेक्ट होता है इसे सफलतापूर्वक 1 क्षति, या के साथ 2 नुकसान नहीं होगा देवताओं की तलवार ।

P

समुराई आने वाले किसी भी हमले को विफल करने का प्रयास करेगा, फिर अपना हमला शुरू करेगा। यदि समुराई के पास 7 सम्मान या अधिक हैं, तो वह अपनी नियमित तलवार के बजाय देवताओं की तलवार का उपयोग करेगा । यह चाल 1 सम्मान की खपत करती है।
पैरी तेज हमलों के खिलाफ एक अच्छा युद्धाभ्यास है, लेकिन यह धीमी गति से ओवरहेड हमलों से प्रबल होगा। अगर हड़ताल सफलतापूर्वक जुड़ती है तो यह 1 नुकसान या देवताओं की तलवार से 2 नुकसान करेगी ।

O

समुराई अपने प्रतिद्वंद्वी पर धीमी गति से हमला करने की कोशिश करेगा। यदि समुराई में 7 सम्मान या उससे ऊपर है, तो वह अपनी नियमित तलवार के बजाय देवताओं की तलवार का उपयोग करेगा । यह चाल 1 सम्मान की खपत करती है।
ओवरहेड स्ट्राइक परियों पर हावी हो सकती है, लेकिन यह तेज हमलों के खिलाफ हार जाएगी। अगर हड़ताल सफलतापूर्वक जुड़ती है तो यह 1 नुकसान या देवताओं की तलवार से 2 नुकसान करेगी ।

देवताओं की तलवार

ऑनर के साथ एक समुराई जो कि 7 या उससे अधिक है , जो देवताओं की तलवार का उपयोग करने की क्षमता प्राप्त करता है । यदि उसका मान 7 से कम हो जाता है, तो देवताओं की तलवार का उपयोग करने की क्षमता उससे निरस्त हो जाएगी। देवताओं की तलवार 1 के बजाय 2 नुकसान पहुंचाती है।

देवताओं की तलवार एक हड़ताल को तलवार की हार की अनुमति नहीं देती है कि यह आमतौर पर हार नहीं मानेगी। उदाहरण के लिए, देवताओं की तलवार की एक तलवार अभी भी एक साधारण उपरि हड़ताल से हार जाएगी, और देवताओं की एक तलवार त्वरित ड्रा एक साधारण त्वरित ड्रॉ पर हावी नहीं होगी। वास्तव में, देवताओं की तथाकथित तलवार वास्तव में यह सब शक्तिशाली नहीं है - शायद यह देवताओं द्वारा खेला गया एक लौकिक मजाक है ...

इंटरेक्शन टेबल

नीचे दिए गए स्टैक स्निपेट में एक तालिका होती है जो स्पष्ट रूप से उन सभी क्रियाओं के विभिन्न संयोजनों के सभी संभावित परिणामों को सूचीबद्ध करती है जो दो समुराई ले सकते हैं। इसे देखने के लिए, "शो कोड स्निपेट" पर क्लिक करें, फिर "रन कोड स्निपेट" पर क्लिक करें।

कोड स्निपेट दिखाएं

कार्यक्रम संचार

टूर्नामेंट को चलाने की सुविधा के लिए, एक नियंत्रक कार्यक्रम "देवताओं" की भूमिका निभाने के लिए लिखा गया था - यह सम्मान और स्वास्थ्य का रिकॉर्ड रखता है और तदनुसार समुराई को मुस्कुराता है। यह खंड बताता है कि आपका कार्यक्रम नियंत्रक कार्यक्रम के साथ कैसे संवाद करेगा।

इनपुट विवरण

कंट्रोलर प्रोग्राम आपके प्रोग्राम को कमांड लाइन से इस तरह बुलाएगा:

<command> <history> <enemy_history> <your_health> <enemy_health> <your_honour> <enemy_honour>

कहा पे:

  • <command>अपने प्रोग्राम को चलाने के लिए आवश्यक कमांड है। उदाहरण के लिए, यदि आपका प्रोग्राम किसी फाइल में है super_sentai.pl, तो कमांड संभवतः है perl super_sentai.pl।

  • <history>आपके द्वारा किए गए चालों का इतिहास है। उदाहरण के लिए, WWBPइसका मतलब होगा कि आपने दो बार इंतजार किया, एक बार झुका, और एक बार रोया।

  • <enemy_history>अपने दुश्मन के कदमों का इतिहास है। उदाहरण के लिए, BBBIइसका मतलब होगा कि आपका दुश्मन तीन बार झुके और एक त्वरित ड्रॉ करे।

  • <your_health> आपका वर्तमान स्वास्थ्य है

  • <enemy_health> दुश्मन का वर्तमान स्वास्थ्य है।
  • <your_honour> आपका वर्तमान सम्मान है।
  • <enemy_honour> दुश्मन का वर्तमान सम्मान है।

पहली बारी के लिए, historyऔर enemy_historyखाली हो जाएगा, इसलिए आपके कार्यक्रम को इस तरह अंतिम चार तर्कों के साथ बुलाया जाएगा:

<command> <your_health> <enemy_health> <your_honour> <enemy_honour>

कृपया इसके लिए तैयार रहें!

सूक्ष्म पाठक यह देख सकते हैं कि दोनों सामुराइ के सम्मान और स्वास्थ्य प्रदान करने वाले चार तर्क कुछ हद तक, सतही हैं; चूंकि यह एक संपूर्ण सूचना खेल है, इसलिए समुराई के सम्मान और स्वास्थ्य को केवल इतिहास का उपयोग करके निर्धारित किया जा सकता है।

ये मान सुविधा उद्देश्यों के लिए प्रदान किए जाते हैं ताकि आपको इतिहास के तर्कों को पार्स न करना पड़े। यह सरल रणनीतियों को लागू करने के लिए उपयोगी साबित होना चाहिए, जैसे कि जब आपका ऑनर 0 हो तो हमला न करें।

आउटपुट विवरण

एक कार्रवाई चुनने के लिए, अपने कार्यक्रम के उत्पादन में एक होना चाहिए W, B, G, I, P, या Oमानक आउटपुट में, क्या कार्रवाई आप बनाना चाहते हैं पर निर्भर करता। यदि आपका प्रोग्राम 1000ms के भीतर कुछ भी आउटपुट नहीं करता है, तो इसे समाप्त कर दिया जाएगा और आपके प्रोग्राम को आउटपुट के रूप में माना जाएगा W।

यदि आपका प्रोग्राम एक से अधिक अक्षरों का आउटपुट देता है, तो केवल पहले अक्षर पर विचार किया जाएगा - इसलिए आउटपुट आउटपुट Parryके समान होगा P।

यदि आपके प्रोग्राम के पहले अक्षर का आउटपुट ऊपर सूचीबद्ध विकल्पों में से कोई भी नहीं है, तो यह डिफ़ॉल्ट हो जाएगा W।

प्रस्तुत करने का प्रारूप

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

अगर मुझे ऐसी समस्याएं आती हैं जो आपके कार्यक्रम को टूर्नामेंट में शामिल होने से रोकती हैं, तो मैं आपकी प्रविष्टि पर एक टिप्पणी छोड़ दूंगा जो समस्या का संकेत देगा।

कृपया अपने सबमिशन में निम्नलिखित शामिल करें:

  1. स्कोरबोर्ड में उपयोग के लिए आपके प्रोग्राम का मानव पठनीय नाम। यहां रिक्त स्थान की अनुमति है; अल्पविराम और यूनिकोड वर्ण नहीं हैं।
  2. आपका प्रोग्राम जिस भाषा में लिखा गया है, कृपया TinyMUSH जैसी भाषाओं तक पहुँचने के लिए अजीब, कठिन लेखन से बचें।
  3. आपके कार्यक्रम का एक छोटा सा सारांश। यह इस बात पर एक विवरण हो सकता है कि कार्यक्रम कैसे काम करता है, या आपके कार्यक्रम के बारे में सिर्फ कुछ स्वाद पाठ (यदि आप सभी गुप्त होना चाहते हैं), या शायद दोनों।
  4. कमांड / आपके प्रोग्राम को चलाने के लिए आवश्यक है। उदाहरण के लिए, यदि आप जावा में अपने सबमिशन को लिख रहे थे, तो आप example.javaसंकलित निर्देश प्रदान करेंगे, javac example.javaफिर निर्देश जारी करेंगे java example।
  5. कार्यक्रम के लिए स्रोत कोड।

सबमिट करने में सहायता करने के लिए, मैं एक सबमिशन टेम्प्लेट प्रदान करता हूं जो यहां पाया जा सकता है । टेम्पलेट प्रस्तुतियाँ को अच्छा बनाता है। मैं इसका उपयोग करने के लिए दृढ़ता से प्रोत्साहित करता हूं।

मैं दो उदाहरण प्रविष्टियाँ भी प्रदान करता हूँ। हालाँकि उदाहरण प्रविष्टियाँ राउंड रॉबिन में भाग लेंगी, लेकिन उनका मुख्य उद्देश्य अंतिम समुराई के शीर्षक के लिए गंभीर दावेदार होने के बजाय टूर्नामेंट के लिए सबमिशन और इनपुट / आउटपुट प्रारूपों को स्पष्ट करना है।

टूर्नामेंट संरचना

यह खंड बताता है कि प्रतिभागियों के बीच टूर्नामेंट कैसे चलाया जाएगा।

नियंत्रण कार्यक्रम

नियंत्रण कार्यक्रम पाइथन 2 में लिखा गया है और इसे अंतिम समुराई शोडाउन गितुब भंडार में पाया जा सकता है । यदि आप इसे स्वयं चलाना चाहते हैं, तो इसे चलाने के निर्देश को लिंक में README.md फ़ाइल में शामिल किया गया है। हालांकि, टूर्नामेंट परिणामों को प्रभावित करने वाले हार्डवेयर अंतर से बचने के लिए मेरे कंप्यूटर पर चलने वाले केवल टूर्नामेंट आधिकारिक होंगे।

नियंत्रण कार्यक्रम को आर्क लिनक्स चलाने वाले लैपटॉप कंप्यूटर पर चलाया जाएगा। इसमें इंटेल कोर i7 प्रोसेसर और 8GB रैम है। मैं अपने कंप्यूटर पर चलने वाली सभी प्रविष्टियों को प्राप्त करने का प्रयास करूंगा, लेकिन यदि आप उन भाषाओं से बचते हैं, जिनकी मैं स्वतंत्र रूप से एक्सेस नहीं कर सकता (जैसा कि मौद्रिक लागत में नहीं)।

स्कोरिंग प्रणाली

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

यदि प्रत्येक प्रोग्राम एक-दूसरे को चलाएगा तो प्रोग्राम की संख्या 8 से कम हो सकती है यदि प्रवेशकों की एक बड़ी संख्या है। ऐसा होने पर मैं यहां एक नोट जोड़ूंगा।

मैं कई बार राउंड रॉबिन चला रहा हूँ क्योंकि नई प्रस्तुतियाँ पोस्ट की गई हैं, लेकिन यह केवल सबसे हाल का राउंड रॉबिन है जो गिनती करेगा।

अयोग्यताएं

आपके कार्यक्रम को टूर्नामेंट से अयोग्य घोषित किया जाना संभव है। अयोग्यता हो सकती है यदि:

  • आपका कार्यक्रम संकलन या चलाने के लिए नहीं है;
  • आपका कार्यक्रम किसी अन्य प्रोग्राम का एक रणनीतिक डुप्लिकेट है (अर्थात, यह अन्य प्रोग्राम के समान सटीक रणनीति लागू करता है);
  • आपका कार्यक्रम नियंत्रक कोड, अन्य कार्यक्रम के कोड, आदि को संशोधित करके अन्य कार्यक्रमों को तोड़फोड़ करने का प्रयास करता है;
  • आपका प्रोग्राम कंट्रोलर कोड में बग का फायदा उठाने का प्रयास करता है। बगों का दोहन करने के बजाय आपको गेट रिपॉजिटरी में एक मुद्दे को खोलना चाहिए, यहां एक टिप्पणी करें, या मुझे चैट में पिंग करें।

पिछले परिणाम

सभी टूर्नामेंटों के विस्तृत परिणाम विकि पृष्ठ पर उपलब्ध कराए गए हैं ।

सबसे हालिया टूर्नामेंट 2015-07-17 07:20 को पूरा हुआ। यहाँ परिणामों का सारांश दिया गया है:

The Observer: 209.0
Coward: 203.0
Monk: 173.0
Elephant Warrior: 157.0
Iniqy: 157.0
Agent 38: 144.0
Ninja: 138.0
Meiyo Senshi: 138.0
Kakashi: 136.0
Yoshimitsu: 131.0
Hermurai: 121.0
Warrior Princess: 120.0
Gargoyle: 119.5
The Honourable: 119.0
Hebi: 118.5
Predictor: 116.0
Whack-a-mole: 107.0
The Fool: 106.0
The Prophet: 105.0
Copy-san: 97.0
YAGMCSE: 80.0
The Waiter: 66.0
Swordsman: 43.0
Spork Holder: 32.5
Blessed Samurai: 27.5
Attacker: 27.0
The Terminator: 17.0
Master Yi: 16.0
king-of-the-hill 
— चिरायता
स्रोत
1
वेटर आश्चर्यजनक रूप से अच्छा कर रहा है। जब यह सम्मान से बाहर हो जाता है तो स्पार्क होल्डर के खिलाफ जीत हासिल करना चाहिए।
— स्टीफनटैग
यह एक साफ-सुथरी चुनौती है। आपने स्पष्ट रूप से बहुत सोचा और इस पर काम किया, और मुझे लगता है कि यह निश्चित रूप से भुगतान किया गया है। बहुत ही उत्तम कार्य। :)
— एलेक्स ए।
1
@ C5H8NNaO4 हां, मैं अगला टूर्नामेंट चलाने से पहले बॉट के अपडेट की जांच करूंगा।
— अनुपम
1
सूचना: मेरा लैपटॉप हाल ही में टूट गया। इस प्रकार, मेरे पास निकट भविष्य में टूर्नामेंट को चलाने का कोई मौजूदा तरीका नहीं है। अगले टूर्नामेंट को चलाने में देरी होगी क्योंकि मैं एक कंप्यूटर खोजने की कोशिश करता हूं जिसका मैं उपयोग कर सकता हूं।
— अनुपम
1
@ लेवी हां! निर्माता ने मुझे एक प्रतिस्थापन भेज दिया जो आज आया। एक टूर्नामेंट चल रहा है जैसा कि हम बोलते हैं।
— अनुपम

जवाबों:

8

भिक्षु (जावा)

भिक्षु सम्मान और देवताओं के आशीर्वाद की प्रशंसा करता है। धैर्य से प्रशिक्षित होने के कारण वह शांति से अपनी प्रार्थनाएँ स्वर्ग में भेजता है जब तक कि वह ईश्वर का पक्षधर न हो जाए।

अपने जीवन का आनंद लेते हुए, वह इसे बचाने की कोशिश करता है। जब वह एक निश्चित दर से अधिक स्वास्थ्य खो रहा है, तो वह खुद को सबसे अच्छा बचाव करता है।

अपने देवताओं के समर्थन की उम्मीद करते हुए वह बेतरतीब ढंग से स्खलन [1] को स्वर्ग भेज देता है , अन्यथा वह जितना हो सके उतना अच्छा लड़ता है।

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

संकलन / भागो

javac Monk.java
java Monk

public class Monk {
    public static void main(String[] args){
        char  r = 'B';
        double  s = Math.random ();
        int n = Math.max (args [0].length ()- 8, 1);
        int p = args.length > 4 ? Integer.parseInt (args [4]):0;
        int l = Integer.parseInt (args [3]);
        int m = Integer.parseInt (args [2]);
        double d = 1 + (20 - m) / n;
        double e = 1 + (20 - l) / n;

        if (((p>8&&s<.7)||l<11||m<2)&&p>0) {
                r=(s<(.14)||d>=2||e/d<.618)?'G':"OPI".charAt((int)(Math.random()*3));
        }

        System.out.print (r);
    }
}

द निंजा (जावा)

निंजा तेज है और तेजी से हमला भी करता है। वह एक दोस्ताना औपचारिक अभिवादन के तुरंत बाद हमला करता है, आगे और हर हमले के बाद झुकने से अपने दुश्मन को भ्रमित करता है।

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

यदि उसे एक घातक घाव मिलता है, तो वह अपने प्रतिद्वंद्वी को जीवित रखने के लिए बाहर जाता है - निश्चित रूप से, सम्मान का एक आदर्श रखते हुए।

javac Ninja.java
java Ninja

public class Ninja {
    public static void main(String[] args){
        char  r = 'B';
        int n = args [0].length ();
        int p = args.length > 4 ? Integer.parseInt (args [4]):0;
        int m = Integer.parseInt (args [2]);
        int a = n % 3;
        if (p>7) {
           if (m>17) {
                r = "BBI".charAt (a);
           } else if (m>13) {
                r = "BII".charAt (a); 
           } else {
               r  = "GIG".charAt (a);
           }

        } else if (p>0) {
           if (m > 10) {
                    r = "BBI".charAt (a);
           } else {
                r="IGI".charAt (n%2);
           }
        }
        System.out.print (r);
    }
}

काकाशी, द कोपाइकस निंजा (जावा)

काकाशी ने अपने विरोधियों को पिछले दो चालों के बीच बेतरतीब ढंग से चुनकर अपने प्रतिद्वंद्वी की चाल को कॉपी किया। यदि प्रतिद्वंद्वी इंतजार करता है, तो वह झुकता है - वह अपना सम्मान भी बनाए रखता है।

javac Kakashi.java
java Kakashi

public class Kakashi {
    public static void main(String[] args){
        char  r;
        String h = args [1];
        if (h=="W" || Integer.parseInt ( args.length > 4?args [4]:"0") < 1){
                 r = 'B';
        } else if (Math.random ()<.1) {
            r = 'I';
        } else {
            r  = h.charAt ((int) (h.length()==1?0: h.length()-Math.random ()*2));
        }

        System.out.print (r);
    }
}


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

ऑब्जर्वर, (नोड.जेएस)

प्रेक्षक ने अपने पिछले 5 चालों से प्रतिद्वंद्वी की अगली चाल की भविष्यवाणी करने की कोशिश की, भविष्यवाणी की गई चाल के लिए सबसे अच्छे समकक्ष का चयन किया।

संपादित करें: नोड को साझा करने के लिए @apsillers को धन्यवाद। बॉयलर बॉयलरप्लेट !.

node observer.js

var argv = process.argv;
var history = argv.length>6?argv[2]:"";
var enemyHistory = argv.length>6?argv[3]:"";
var offset = 8 - argv.length;
var my = { health:+argv[4-offset], honor:+argv[6-offset], history:history };
var enemy = { health:+argv[5-offset], honor:+argv[7-offset], history:enemyHistory };
my.godSword = my.honor >= 7;
enemy.godSword = enemy.honor >= 7;
function decide() {
    process.stdout.write(arguments[Math.floor(arguments.length*Math.random())]);
    process.exit();
}

var m = {
    m:{},
    l:function (a,b) {
        if (!this.m[a]) {
           this.m [a] = [];
        }
        this.m[a].push (b);
    },
    p:function (a) {
       for (var k=0;k<a.length;k++)
       for (var j=1;j<a.length;j++)
       for (var i=-1+k; i<a.length-j; i++)this.l (a.slice (i,i+j),a[i+j]);
    },
    a:function (a) {
      if (!this.m[a])return;
      return this.m[a][0|Math.random () * this.m[a].length-1]
    }
}
var g={
   B:"IPO",
   G:"B",
   I:"PG",
   O:"IG",
   P:"OG",
   W:"I"
}
var c,i=0;
m.p(enemy.history);
while (!c && i++<enemy.history.length) {
   c=m.a (enemy.history.slice (i));
}
decide.apply  (0,my.honor < 7?["B"]:g[c].split (''))

संपादित करें: मैं पर्यवेक्षक में एक प्रमुख दोष था, मुझे वास्तव में नहीं पता कि मैंने कल रात क्या सोचा था। ऐसा लगता है कि वह केवल दुश्मन की पिछली दो चालों को देखता था। उन्होंने आश्चर्यजनक रूप से इस तरह अच्छा किया।

उनकी स्मृति अब दुश्मनों के इतिहास के सबसे लंबे (अंत) भाग के लिए विचलित हो जाती है जिसे उन्होंने पहले ही देख लिया है। इसमें सभी चालों के साथ एक सरणी होती है जो चालों के इतिहास का अनुसरण करती है। एक को यादृच्छिक रूप से चुना गया है। इसलिए यदि एक कदम का अधिक बार अनुसरण किया जाता है, तो इसे उठाया जाना अधिक संभव है। मार्कोव चेन की तरह।

ऑब्जर्वर, अब गार्ड भी।

[१]: टीआईएल: स्खलन का एक धार्मिक अर्थ है

— C5H8NNaO4
स्रोत
अभी आप # 1 और # 3 हैं! अच्छा बॉट्स! :)
— अप्सिलर्स
द ऑब्जर्वर के साथ जीतने पर बधाई। हरे रंग की टिक अब आपकी है: D
— absinthe
7

मेयो सेन्शी (जावा)

मेइजियो के बारे में ज्यादा जानकारी नहीं है। वे आम तौर पर खेल के खेल में भाग नहीं लेते हैं, लेकिन अपने प्रतिद्वंद्वियों का आकलन करने के लिए इसने एक योद्धा को भेजा है।

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

चलाने को संकलित करने के लिए, यह मानक जावा तरीका है:

> javac MeiyoSenshi.java
> java MeiyoSenshi

public class MeiyoSenshi {
    public static void main(String[] args){
        System.out.print(
                Integer.valueOf(args[args.length<5?0:2])>12 ||
                Integer.valueOf(args[args.length<5?2:4])<1  ?
                "B":
                "IPO".charAt((int)(Math.random()*3))
        );
    }
}
— Geobits
स्रोत
7

स्पार्क होल्डर (रूबी)

स्पार्क होल्डर पहले मोड़ पर झुकता है, फिर बाद में अनियमित रूप से कार्य करता है। यह दो उदाहरण प्रविष्टियों में से एक है।

कमान: ruby spork-holder.rb

if ARGV.length == 4
    print "B"
else
    print ["W", "B", "G", "I", "P", "O"].sample
end

वेटर (मार)

वेटर केवल हर मोड़ पर इंतजार करता है। यह दो उदाहरण प्रविष्टियों में से एक है।

कमान: echo W

कोई स्रोत कोड आवश्यक नहीं है।

— चिरायता
स्रोत
7

कायर (Node.js)

मैं एक कायर कर रहा हूँ / यह एक चमत्कार मैं साँस लेने की हिम्मत है
जबर्दस्ती / सौम्य गर्मी हवा तक

  • जब आप झुक रहे हों, तब धनुष BXBXBX/ BBB(आपको हिट करने के लिए ) पैटर्न की जाँच करें ।
  • GXGXGXजब आप रखवाली कर रहे हों, तब झुकने के लिए पैटर्न की जाँच करें ।
  • यदि उसका रैंडम शौर्य रोल उस दौर के लिए उसके डर को कम कर देता है, तो वह एक हिट के लिए प्रयास करेगा।
    • देवताओं की तलवार होने से वह बहादुर बन जाता है।
    • देवताओं की तलवार के साथ एक प्रतिद्वंद्वी उसे और अधिक भयभीत बनाता है।
    • एक प्रतिद्वंद्वी जो कम से कम 5 स्वास्थ्य या उससे अधिक की ओर जाता है, उसे थोड़ा डर भी देता है।
  • अन्यथा, वह पहरेदारी और गेंदबाजी करता है।

यदि आप एक Node.js सबमिशन लिखना चाहते हैं , तो कृपया मेरे बॉयलरप्लेट कोड का उपयोग करने के लिए स्वतंत्र महसूस करें; decideफ़ंक्शन सहित सब कुछ पूरी तरह से सामान्य है और लेने के लिए स्वतंत्र है।

node coward.js

var argv = process.argv;
var history = argv.length>6?argv[2]:"";
var enemyHistory = argv.length>6?argv[3]:"";
var offset = 8 - argv.length;
var my = { health:+argv[4-offset], honor:+argv[6-offset], history:history };
var enemy = { health:+argv[5-offset], honor:+argv[7-offset], history:enemyHistory };
my.godSword = my.honor >= 7;
enemy.godSword = enemy.honor >= 7;
function decide() {
    process.stdout.write(arguments[Math.floor(arguments.length*Math.random())]);
    process.exit();
}

var enemyGuards = !!enemy.history.match(/G.G.G.$/);
var enemyBows = !!enemy.history.match(/(B.B.B.$)|(BBB$)/);

// open with a bow
if(!my.history) { decide("B"); }

// enemy will likely bow? Hit them with your super sword! (or bow)
if((!enemy.honor || enemyBows)) {
    if(my.godSword) { decide("P","I","O"); }
    else { decide("B"); }
}

// no point in hitting them if they're going to guard
if(enemyGuards) { decide("B"); }

// calculate bravery level
var braveryLevel = 0.3;
braveryLevel += (my.godSword * 0.2) - (enemy.godSword * 0.2);
braveryLevel -= (enemy.health - my.health > 5) * 0.1;

// if we're feeling brave, hit them
if(Math.random() < braveryLevel && my.honor) { decide("P","I","O"); }

// if we didn't just guard, and we're not feeling brave, cower in fear
if(!my.history.match(/G$/)) {
    decide("G");
}

// if we did just guard, and we're feeling cowardly,
//   if we don't have sword of the gods, bow
//   otherwise, do anything except guard
if(!my.godSword) {
    decide("B");
} else {
    decide("B","P","I","O");
}
— apsillers
स्रोत
1
यह एक कठिन बॉट है। बहुत बढ़िया बॉयलरप्लेट; मैं अभी इसका उपयोग करूंगा। साझा करने के लिए धन्यवाद :)
— C5H8NNO4
6

व्हेक-ए-मोल (R)

दुश्मन जब झुकने की संभावना है, तो गार्ड।

args <- commandArgs(TRUE)
L <- length(args)
my_health <- as.integer(args[L-3])
enemy_health <- as.integer(args[L-2])
my_honour <- as.integer(args[L-1])
enemy_honour <- as.integer(args[L])
if(L>4){enemy_history <- args[L-4]}else{enemy_history <- ""}
if(my_honour<1){
    out <- "B"
}else if (enemy_honour<=1 | grepl("BB$",enemy_history)){
    out <- sample(c("I","O"),1)
}else{
    out <- "G"
}
cat(out)

का उपयोग कर चलाएं Rscript Whack-a-mole.R।

— plannapus
स्रोत
1
अच्छी नौकरी, प्लस मुझे नाम से प्यार है।
— एलेक्स ए।
3

हाथी योद्धा (जावा)

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

संकलन: javac ElephantWarrior.java
कमांड:java ElephantWarrior

import java.util.LinkedList;

//Elephants never forget
class ElephantWarrior
{


  static LinkedList<Choice> analysis = new LinkedList<Choice>();

  public static void main(String[] args){
      if(args.length < 6){ respond("B");}   
      String myhis = args[0];
      String enHis = args[1];
      int health = Integer.parseInt(args[2]);
      int enHealth = Integer.parseInt(args[3]);
      int honour = Integer.parseInt(args[4]);
      int enHonour = Integer.parseInt(args[5]);

        //Bow a few times until I know how he operates
        if(enHis.length() <= 5){
            respond("B");
        }

        //Special cases
        //If I'm at 0 honor, better bow
        else if(honour <= 0){
            respond("B");

        }
        else{
          analyze(enHis);

          //Narrow it down to applicable choices
          char hisLast = enHis.toCharArray()[enHis.toCharArray().length - 1];
          LinkedList<Choice> hisOptions = new LinkedList<Choice>();
          for(Choice c: analysis){
              if(c.pattern.toCharArray()[0] == hisLast){
                  hisOptions.add(c);
              }
          }

           //Default to assuming they bow
          char hisNext = 'B';
          int mostLikely = 0;

          //What will they do next?
          for(Choice c : hisOptions){
              if(c != null && c.probability > mostLikely){
                  //System.out.println("Option = " + c.pattern);
                  //System.out.println("Prob = " + c.probability);
                  mostLikely = c.probability;
                  hisNext = c.pattern.toCharArray()[1]; }
          }

          //Now go through potential case
          switch(hisNext){
              case 'W':
                  respond("I");
                  break;
              case 'B': 
                  respond("O");
                  break;
              case 'G':
                  respond("B");
                  break;
              case 'I':
                  if(enHonour  > 0){
                      respond("P");
                  }
                  else{
                      respond("B");
                  }
                  break;
              case 'P':
                  respond("O");
                  break;
              case 'O':
                  respond("I");
                  break;
              default:
                  respond("G");
          }
        }
    }





      static void analyze(String his){

        //Keep track of his previous moves
        char[] shortString = his.substring(1,his.length() - 1).toCharArray();
        char[] longString = his.toCharArray();
        for( int i = 0; i < shortString.length; i++) {
          String pattern = "" + longString[i] + shortString[i];
          boolean exists = false;
          for(Choice c : analysis){
              if(c.pattern.equals(pattern)){
                  exists = true;
                  c.probability++;
              }
          }
          if(!exists){
              analysis.add(new Choice(pattern, 1));
          }
        }
      }

      private static void respond(String s){
            System.out.println(s);
            System.exit(0);
        }

    }

class Choice{
        String pattern;
        int probability;

       Choice(String p, int i){
            pattern = p;
            probability = i;
       }
}
— कैन
स्रोत
2
मैंने इसका परीक्षण नहीं किया है, लेकिन ऐसा लगता है कि यह पहली बारी में सीमा से बाहर चला जाएगा जहां केवल चार हैं args।
— जोबिट्स
ठीक है, एहसास नहीं था कि उन सभी में शामिल नहीं किया जाएगा। मुझे लगता है कि स्पष्ट रूप से एक रिक्त स्ट्रिंग केंट पारित किया जा सकता है, धन्यवाद!
— कैन
@ कट्या अभी तय है, btw, टूर्नामेंट में शामिल किया जाना चाहिए।
— कैन
3

योद्धा राजकुमारी (जूलिया)

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

योद्धा राजकुमारी हमले और सम्मान को प्राथमिकता देती है, और जरूरत पड़ने पर आत्म-संरक्षण का संकल्प लेती है। वह बल्कि उत्सुक है और कभी इंतजार नहीं करती। फुर्तीला बने रहने के प्रयास में, वह एक ओवरहेड हमले का उपयोग नहीं करता है।

के रूप में सहेजें warrior-princess.jlऔर कमांड लाइन से चलाएं जैसे:

julia warrior-princess.jl <arguments>

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

type Samurai
    history::String
    health::Int
    honor::Int
end

A = length(ARGS) < 5 ? ["", "", ARGS] : ARGS

me = Samurai(A[1], int(A[3]), int(A[5]))
opponent = Samurai(A[2], int(A[4]), int(A[6]))


if length(me.history) == 0

    # Always begin the match with an honorable bow
    action = "B"

elseif (!ismatch(r"[OIP]", opponent.history) && me.history[end] != 'G') ||
       (me.health < 2 && me.honor > 0)

    # Guard if the enemy has not yet attacked and I did not previously
    # guard, or if my health is low and my honor is sufficient
    action = "G"

elseif me.honor < 2

    # Bow if I'm low on honor
    action = "B"

elseif opponent.honor >= 7 && opponent.history[end] ∈ ['B', 'W']

    # Assume the enemy will attack with the Sword of the Gods if they
    # most recently bowed or waited
    action = "I"

else
    action = "P"
end

println(action)
— एलेक्स ए।
स्रोत
1
अगर मैं गलत नहीं हूँ तो आपकी पहली KotH प्रविष्टि और पहली Julia KotH प्रविष्टि: बधाई!
— प्लेनैपस
@plannapus धन्यवाद! : D शायद मैं इसकी आदत बना लूँगा।
— एलेक्स ए।
3

गार्गॉयल (जावा)

सम्मान की खपत के बिना रक्षात्मक कदम का उपयोग करने की कोशिश करता है।

चूंकि यह एक जावा प्रविष्टि है:

> javac Gargoyle.java
> java Gargoyle

public class Gargoyle { 
    public static void main(String args[]) {
        if (args.length < 5 || Integer.valueOf(args[4]) > 0) {
            System.out.println("IPO".charAt((int)(Math.random()*3)));
        } else if (args[0].charAt(args[0].length()-1) != 'G') {
            System.out.println('G');
        } else {
            System.out.println('B');
        }
    }
}
— CommonGuy
स्रोत
3

स्वॉर्ड्समैन (C / Java)

स्वॉर्ड्समैन पहले मोड़ पर झुकता है और जब भी वह सम्मान पर कम चल रहा होता है। वह तब जांचता है कि प्रतिद्वंद्वी पिछली बारी में झुका या बचाव नहीं किया या इंतजार नहीं किया। यदि प्रतिद्वंद्वी नहीं था, तो इस बात की बड़ी संभावना है कि वह इनमें से किसी एक को चालू कर देगा और तलवार चलाने वाला इस प्रकार बेतरतीब ढंग से प्रतिद्वंद्वी पर वार करेगा। यदि यह सच नहीं है, तो वह बचाव करता है यदि उसने पिछले मोड़ का बचाव नहीं किया है। यदि वह था, वह सम्मान हासिल करने के लिए झुकता है।

सी संस्करण:

#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void print_and_exit(char* str)
{
    puts(str);
    exit(0);
}

int main(int argc, char** argv){

    srand(time(NULL));
    char* attack_moves[]={"I", "P", "O"};
    int random_num = rand() % 3;

    if(argc == 5 || atoi(argv[5]) == 0)
        print_and_exit("B");
    else if(argv[2][strlen(argv[2])-1] != 'B' && argv[2][strlen(argv[2])-1] != 'G' && argv[2][strlen(argv[2])-1] != 'W')
        print_and_exit(attack_moves[random_num]);
    else if(argv[1][strlen(argv[1])-1] != 'G')
        print_and_exit("G");

     print_and_exit("B");
}

GCC (कंपाइलर) स्थापित करें और कोड को " Swordsman.c " नाम की फ़ाइल में संकलित करने के लिए सहेजें :

gcc Swordsman.c -o Swordsman

" स्वॉर्ड्समैन " नामक निष्पादन योग्य बनाया जाएगा। का उपयोग कर चलाएं

Swordsman

जावा संस्करण:

public class Swordsman {

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }
    public static void main(String[] argv) {

        String attack_moves[]={"I", "P", "O"};
        int random_num = (int)(Math.random()*3);

        if(argv.length == 4 || Integer.valueOf(argv[5]) == 0)
            print_and_exit("B");
        else if(argv[2].charAt(argv[2].length()-1) != 'B' && argv[2].charAt(argv[2].length()-1) != 'G' && argv[2].charAt(argv[2].length()-1) != 'W')
            print_and_exit(attack_moves[random_num]);
        else if(argv[1].charAt(argv[1].length()-1) != 'G')
            print_and_exit("G");

         print_and_exit("B");
    }

}

Javac (कंपाइलर) स्थापित करें और कोड को " Swordsman.java " नामक फाइल में संकलित करने के लिए सहेजें :

javac Swordsman.java

" Swordsman.class " नाम की क्लास फाइल बनाई जाएगी। का उपयोग कर चलाएं

java Swordsman

हमलावर (जावा)

हमलावर को कुछ भी परवाह नहीं है सिवाय इसके कि वह अपने प्रतिद्वंद्वी को मरवाना चाहता है। वह बेतरतीब ढंग से हमले की एक चाल पर हमला करता है और यदि कम सम्मान, धनुष है।

public class Attacker {

    static int position = -1;

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }
    public static void main(String[] argv) {

        String attack_moves[]={"I", "P", "O"};
        position = (position + 1) % 3;

        if(argv.length != 5 && Integer.valueOf(argv[5]) == 0)
            print_and_exit("B");
        else 
            print_and_exit(attack_moves[position]);
    }

}

Javac (संकलक) स्थापित करें और कोड को एक फाइल में सहेजें, जिसे " Attacker.java " कमांड के नाम से संकलित किया गया है:

javac Attacker.java

" Attacker.class " नाम की क्लास फाइल बनाई जाएगी। का उपयोग कर चलाएं

java Attacker

प्रिडिक्टर (C / Java)

शत्रु चाल को भविष्यवाणी करता है। पहली बारी में, यह एक यादृच्छिक चाल का उपयोग करता है। धनुष अगर उसका सम्मान कम है, अगर दुश्मन का सम्मान कम है या पिछले मोड़ में झुका है तो हमला करता है। यदि पूर्ववर्ती ने पिछले मोड़ पर पहरा नहीं दिया है, तो वर्तमान मोड़ में गार्ड। एल्स, वैसी ही चाल करता है जैसा कि दुश्मन ने पिछली बारी में किया है, बशर्ते कि वह 'W'किस स्थिति में न हो, प्रिडिक्टर धनुष।

सी संस्करण:

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

void print_and_exit(char* str)
{
    puts(str);
    exit(0);
}

int main(int argc, char** argv){

    srand(time(NULL));
    int random = rand() % 5;
    char* moves[] = {"B", "G", "I", "P", "O"};

    if(argc == 5)
        print_and_exit(moves[random]);

    if(atoi(argv[5]) <= 0)
        print_and_exit(moves[0]);
    if(atoi(argv[6]) <= 0)
        print_and_exit(moves[4]);
    if(argv[2][strlen(argv[2])-1] == 'G')
        print_and_exit(moves[4]);
    if(argv[1][strlen(argv[1])-1] != 'G')
        print_and_exit(moves[1]);

    if(argv[2][strlen(argv[2])-1] != 'W'){
        char buf[2]={0};
        *buf = argv[2][strlen(argv[2])-1];
        print_and_exit(buf);
    }

    print_and_exit(moves[0]);

}

GCC (कंपाइलर) स्थापित करें और कोड को " प्रिडिक्टॉरसी " नामक फाइल में संकलित करने के लिए सेव करें :

gcc Predictor.c -o Predictor

" प्रिडिक्टर " नाम का निष्पादन योग्य बनाया जाएगा। का उपयोग कर चलाएं

Predictor

जावा संस्करण:

public class Predicator{

    public static void print_and_exit(String str)
    {
        System.out.println(str);
        System.exit(0);
    }

    public static void main(String[] argv){

        int random = (int)(Math.random() * 5);
        String moves[] = {"B", "G", "I", "P", "O"};

        if(argv.length == 4)
            print_and_exit(moves[random]);
        else if(Integer.valueOf(argv[5]) <= 0)
            print_and_exit(moves[0]);
        else if(Integer.valueOf(argv[6]) <= 0)
            print_and_exit(moves[4]);
        else if(argv[2].charAt((argv[2].length())-1) == 'G')
            print_and_exit(moves[4]);
        else if(argv[1].charAt((argv[1].length())-1) != 'G')
            print_and_exit(moves[1]);
        else if(argv[2].charAt((argv[1].length())-1) != 'W'){
                    print_and_exit(""+argv[2].charAt((argv[2].length())-1));
        }
        else
            print_and_exit(moves[0]);
    }
}

Javac (कंपाइलर) स्थापित करें और कोड को " Predicator.java " नामक फाइल में संकलित करने के लिए सहेजें :

javac Predicator.java

" Predicator.class " नाम की क्लास फाइल बनाई जाएगी। का उपयोग कर चलाएं

java Predicator

निश्चित नहीं है कि ये बॉट्स कितने प्रभावी होंगे क्योंकि मेरे पास इसे जांचने के लिए python2 दुभाषिया नहीं है।

— Spikatrix
स्रोत
1
मैंने इसका (हमलावर) परीक्षण नहीं किया है, लेकिन ऐसा लगता है कि यह पहली बारी में सीमा से बाहर चला जाएगा जहां केवल चार आर्ग हैं।
— ज्योबिट्स 18
हमलावर ArrayIndexOutOfBoundsExceptionपहले मोड़ पर दे रहा है , जिससे उसे पहले मोड़ पर इंतजार करना पड़ रहा है। इसके अलावा यह कार्य कर रहा है।
— अपरहण
@ कट्या और जोबिट्स, फिक्स्ड। इसे जगह देने के लिए धन्यवाद।
— स्पिकट्रिक्स
भविष्यवक्ता को चलाते समय, मुझे segmentation fault (core dumped)24 के बाद का दौर मिलता है
— C5H8NNO4
@ C5H8NNaO4 ने समस्या का समाधान किया। सभी तीन बॉट के लिए अद्यतन कोड। अब ठीक काम करना चाहिए। इस पर ध्यान दिलाने के लिए धन्यवाद! :
— स्पिकैट्रिक्स
2

मास्टर यी (अजगर)

मास्टर हत्यारे शुरुआती गेम में बहुत एहसान हासिल करते हैं, जब तक कि वह अजेय नहीं हो जाता है तब तक उसका निर्माण होता है। हमले की कोशिश करता है जब वे कम से कम यह उम्मीद करते हैं।

import sys, random

class MasterYi(object):
    def __init__(self):
        self.attack = lambda: random.choice(['I','P','O'])
        self.bow   = "B"
        self.guard = "G"
        self.wait  = "W"
        if len(sys.argv)>6:
            self.hist = sys.argv[1]; self.ohist = sys.argv[2]
            self.hp   = sys.argv[3]; self.ohp   = sys.argv[4]
            self.hon  = sys.argv[5]; self.ohon  = sys.argv[6]
        else:
            self.hist = [];          self.ohist = []
            self.hp   = sys.argv[1]; self.ohp   = sys.argv[2]
            self.hon  = sys.argv[3]; self.ohon  = sys.argv[4]
        self.last  = self.hist  and self.hist[-1]  or "W"
        self.olast = self.ohist and self.ohist[-1] or "W"
        self.oGuarder = len(self.ohist)>4 and self.ohist[-4]==self.ohist[-2]=="G"

    def move(self):
        if self.hon < 1: return self.bow
        if self.olast == "G": return self.attack
        if self.hon > 6:
            if self.oGuarder: return self.bow
            if self.ohon > 6: return self.guard
            if self.ohon < 7: return self.attack
            return self.attack
        if self.ohon > 6: return self.guard
        return self.bow

Yi = MasterYi()
print(Yi.move())

चलाने के लिए: इस रूप में सहेजें MasterYi.py

python MasterYi.py <args>
— mbomb007
स्रोत
2

कॉपी-सान (C)

अपने प्रतिद्वंद्वी के हर कदम की नकल करता है। बहुत यकीन है कि वह हारने की गारंटी है। संकलित करें:gcc copy-san.c

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc == 5) {
        putchar('B');
    } else {
        char *enemy_hist = argv[2];
        size_t len = strlen(enemy_hist);
        putchar(enemy_hist[len - 1]);
    }
    putchar('\n');
    return 0;
}
— Functino
स्रोत
2

हेबी (जावा)

हेबी सांप के रास्ते का पालन करें।

देवताओं के आशीर्वाद के लिए साँप की कोई आवश्यकता नहीं है।

साँप अपने प्रहार करता है; समुद्र तट पर लहरों की तरह, जो आता है वह वापस आ जाता है।

सांप कभी इंतजार नहीं करता।

साँप को वाक्पटुता का कोई मतलब नहीं है, इसे पायथन में लिखा गया है।

चल रहे निर्देश:

> javac hebi.java
> java hebi

कोड निकाय:

public class hebi{

    public static void main(String args[]){

        if( (args.length < 5) || (args[0].length() % 18 == 0) ) System.out.println( "IPO".charAt((int)(Math.random()*3)) );
        else{

            int hist_size = args[0].length();

            if      (hist_size % 3 == 1) System.out.println("G");
            else if (hist_size % 3 == 2) System.out.println("B");
            else{

                if     (hist_size % 18 ==  9) System.out.println(args[0].charAt(hist_size -  3));
                else if(hist_size % 18 == 12) System.out.println(args[0].charAt(hist_size -  9));
                else if(hist_size % 18 == 15) System.out.println(args[0].charAt(hist_size - 15));
                else{

                    char move_head = args[0].charAt( (hist_size / 18) * 18 );
                    char move_mid;
                    if( hist_size % 18 == 3 ){
                        if     ( move_head == 'I' ) move_mid = "PO".charAt((int)(Math.random()*2));
                        else if( move_head == 'O' ) move_mid = "IP".charAt((int)(Math.random()*2));
                        else                        move_mid = "OI".charAt((int)(Math.random()*2));
                        System.out.println(move_mid);
                    }
                    else{
                        move_mid = args[0].charAt( ((hist_size / 18) * 18) + 3 );
                        char move_tail;

                        if( move_head == 'I' ){
                            if( move_mid == 'P' ) move_tail = 'O';
                            else                  move_tail = 'P';
                        }else if( move_head == 'P' ){
                            if( move_mid == 'O' ) move_tail = 'I';
                            else                  move_tail = 'O';
                        }else{
                            if( move_mid == 'I' ) move_tail = 'P';
                            else                  move_tail = 'I';
                        }

                        System.out.println( move_tail );

                    }

                }

            }

        }

    }

}
— DoctorHeckle
स्रोत
2

द माननीय (जावा)

सब से ऊपर माननीय मान सम्मान। यही है, हर किसी के ऊपर उसका सम्मान। यदि शत्रु समुराई का बड़ा या समान सम्मान है, तो वह झुकता है। कोई भी व्यक्ति उससे अधिक सम्मानित नहीं होगा। अन्यथा, वह एक यादृच्छिक चाल करता है। वह कभी भी एक पंक्ति में दो बार गार्ड नहीं करता - यह बेईमानी होगी!

संकलन करना:

> javac TheHonourable.java
> java TheHonourable

स्रोत:

public class TheHonourable {
    public static void main(String[] args) {
        char move;

        if (args.length < 5) {
            move = 'B';
        } else if (Integer.valueOf(args[5]) >= Integer.valueOf(args[4])){
            move = 'B';
        } else {
            move =  (args[0].endsWith("G")) ?
                    "IPO".charAt((int)(Math.random()*3)) :
                    "GIPO".charAt((int)(Math.random()*4));
        }

        System.out.print(move);
    }
}
— नील
स्रोत
1

धन्य समुराई (अजगर)

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

import sys
import random
class BlessedSamurai(object):
    def __init__(self):
        if len(sys.argv) < 7:
            print("B")
        else:
            self.attack = ['O', 'I', 'P']
            self.hp = sys.argv[3]
            self.ohp = sys.argv[4]
            self.hon = sys.argv[5]
            self.last = sys.argv[1][-1]
            print(self.move())

    def move(self):
        #check if I have low health or should rush the kill
        if (self.hp < 5 or self.ohp < 5) and self.hon > 0:
            return(random.choice(self.attack))
        # charge honour to get SOTG
        elif self.hon < 7:
            return 'B'
        #Alternate guarding and attacking
        else:
            if self.last == 'G':
                return(random.choice(self.attack))
            return 'G'
Sam = BlessedSamurai()

चलाने के लिए:
BlessedSamurai.py के रूप में सहेजें 

python BlessedSamurai.py <args>
— Stranjyr
स्रोत
4
आपके कार्यक्रम को इसके कदम को प्रिंट करने की आवश्यकता है ।
— mbomb007
3
मैंने इसका परीक्षण नहीं किया है, लेकिन ऐसा लगता है कि यह पहले मोड़ पर सीमा से बाहर चला जाएगा जहां केवल चार आर्ग हैं।
— ज्योबिट्स
मैंने जो किया, उसका एक समान प्रारूप इस्तेमाल किया। @Stranjyr, मैं क्या आर्ग करने के लिए किया था पर एक नज़र रखना।
— mbomb007
दोनों को धन्यवाद! मेरे पास अभी एक अजगर दुभाषिया तक पहुंच नहीं है, लेकिन मुझे लगता है कि मैंने मुद्दों को तय कर दिया है। किसी तरह मैं पूरी तरह से चूक गया कि निर्देशों के पहले सेट का इतिहास नहीं होगा।
— २०:२
नमस्ते, आपके कार्यक्रम में एक छोटा सा बग था "वैश्विक नाम 'अंतिम' परिभाषित नहीं है"। चूंकि यह एक छोटा सा बग lastहै self.lastजिसे मैंने बदल दिया है जिससे समस्या ठीक होती है।
— अनुपम
1

हरमुराई (C ++)

अपने प्रतिद्वंद्वी को स्वीकार करता है, और थोड़ा पागल है। जानना चाहता है कि क्या वह अन्य समुराई कर सकता है, क्योंकि वह अभी भी खुद को समुराई नहीं मान सकता। यह जानने से पहले उनका कभी न भूलने वाला सपना हकीकत बन गया। जिससे उसका सिर खर्च हो सके ...

#include <stdio.h>
#include <string>
#include <sstream>

using namespace std;

char getLastAttack(string enemy_history)
{
    size_t found = enemy_history.find_last_of("IPO");
    if(found == string::npos)
    {
        return 'I';
    }

    return enemy_history[found];
}

int main(int argc, const char * argv[])
{
    if(argc != 7){
        printf("B");
        return 0;
    }

    string enemy_history(argv[2]);

    int ho;
    string honour(argv[5]);
    stringstream(honour) >> ho;

    if(ho > 20){
        char atk = getLastAttack(enemy_history);
        printf("%c", atk);
        return 0;
    }

    char lastMove = enemy_history[enemy_history.length()-1];
    if(lastMove == 'W' || lastMove == 'G')
        lastMove = 'B';
    printf("%c", lastMove);
    return 0;
}

इनिक्की (C ++)

जितना संभव हो सके स्ट्राइक। जब वह खतरे में होता है तो अजेय हमले मोड में चला जाता है।

#include <stdio.h>
#include <string>
#include <sstream>

using namespace std;

char getLastAttack(string enemy_history)
{
    size_t found = enemy_history.find_last_of("IPO");
    if(found == string::npos)
    {
        return 'I';
    }

    return enemy_history[found];
}

int main(int argc, const char * argv[])
{
    if(argc != 7){
        printf("B");
        return 0;
    }

    string history(argv[1]);
    string enemy_history(argv[2]);
    string health(argv[3]);
    string enemy_health(argv[4]);
    string honour(argv[5]);
    string enemy_honour(argv[6]);

    int he, enemy_he, ho, enemy_ho;
    stringstream(health) >> he;
    stringstream(enemy_health) >> enemy_he;
    stringstream(honour) >> ho;
    stringstream(enemy_honour) >> enemy_ho;

    if(ho > 6 || ((he < 6 || enemy_he < 6) && ho > 0))
    {
        char atk = getLastAttack(enemy_history);
        printf("%c", atk);
        return 0;
    }


    printf("B");
    return 0;
}

दोनों C ++ में लिखे गए हैं। संकलन करना:

g++ iniqy.cpp -o iniqy

लिनक्स पर चलाने के लिए: ./iniqy

विंडोज पर चलाने के लिए: iniqy.exe

— Herjan
स्रोत
1

टर्मिनेटर (माणिक)

टर्मिनेटर अपने स्वास्थ्य पर ध्यान नहीं देता है। टर्मिनेटर के पास सम्मान की कोई धारणा नहीं है। टर्मिनेटर को भविष्य से भेजा जाता है और बस अपने प्रतिद्वंद्वी को समाप्त करने के लिए निर्धारित किया जाता है। ऐसा वह अपने विरोधियों की चाल देखकर करता है, और कुछ नहीं। यह चालों का नमूना लेता है और इस तरह के जटिल तरीके से उचित प्रतिक्रिया की गणना करता है कि कोई भी वर्तमान तकनीक टर्मिनेटर के कार्यों की भविष्यवाणी नहीं कर सकती है। वास्तव में, 2015 में रहने वाले किसी को टर्मिनेटर कुछ यादृच्छिक लग सकता है ...

responses = {
  ?W => %w(B I),
  ?B => %w(I O),
  ?G => %w(B B),
  ?I => %w(G P),
  ?P => %w(B O),
  ?O => %w(G I)
}

if ARGV.size > 4
  pool = ARGV[1].chars.map{ |c| responses[c] }.flatten
  puts pool.sample
else
  puts %w(O I P B).sample
end
— daniero
स्रोत
1

एजेंट 38 [1] (सी)

व्यापक आनुवंशिक हेरफेर के उत्पाद के रूप में, एजेंट 38 में एक सुपर [2] -समुराई की काया और मानसिक तीक्ष्णता है , और निश्चित रूप से अपने सभी असहाय [उद्धरण वांछित] त्रुटिपूर्ण [उद्धरण वांछित] प्रतियोगियों से श्रेष्ठ है।

//Agent 38
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#ifdef _WIN32
#include <Windows.h>
unsigned int tick_count(){
    return GetTickCount();
}
#else
#include <sys/time.h>
unsigned int tick_count(){
    struct timeval t;
    gettimeofday(&t, NULL);
    return 1000 * t.tv_sec + t.tv_usec / 1000;
}
#endif

float program[5][4][4][4][4]={
    {{{{-1.192779,0.693321,-1.472931,-0.054087},{0.958562,0.557915,0.883166,-0.631304},{-0.333221,1.410731,0.496346,0.087134},{0.459846,0.629780,-0.479042,-0.025909}},{{0.547976,1.059051,-0.748062,-0.675350},{-0.607591,-0.152156,-0.400350,-0.685337},{1.686450,0.628706,0.312865,0.324119},{1.652558,0.403733,-0.456481,-0.081492}},{{0.371629,-0.036948,-0.982682,0.065115},{1.360809,0.681294,0.505074,0.782737},{-0.545192,0.954937,-0.727853,0.273542},{-0.575777,1.615253,-0.064885,-0.516893}},{{0.577015,-0.112664,0.456595,-0.007560},{-0.660930,-0.738453,0.668093,1.716388},{1.972322,0.108558,0.535114,-0.337916},{0.640208,-0.019680,-0.769389,0.873087}}},{{{-0.021140,-0.095956,-0.098309,-0.280295},{-0.926284,1.724028,0.278855,0.678060},{0.153006,-1.860947,-0.577699,-1.931683},{-0.187152,0.529719,-1.164157,0.125499}},{{0.582208,-0.835029,-0.329857,0.088176},{-0.030797,0.389396,0.584636,-0.025866},{-0.736538,1.624658,0.690493,0.387515},{0.973253,-0.530825,1.934379,-0.872921}},{{0.812884,0.138399,-1.452478,-1.504340},{-0.119595,0.986078,-0.993806,1.102894},{0.848321,-0.268764,0.876110,0.782469},{0.948619,-0.557342,0.749764,-0.712915}},{{-1.195538,0.783784,-1.973428,-0.873207},{0.085426,-0.241360,-0.534561,-0.372105},{0.029696,-0.906821,0.932227,-0.834607},{0.764903,-0.276117,-1.346102,-0.093012}}},{{{0.168113,0.855724,1.817381,-0.547482},{0.468312,0.923739,-0.723461,0.798782},{-0.875978,-0.942505,-0.684104,-0.046389},{0.893797,-0.071382,0.283264,0.811233}},{{0.391760,0.309392,-0.045396,-0.977564},{0.085694,0.257926,-0.775461,0.060361},{0.486737,-0.175236,0.806258,-0.196521},{0.691731,-0.070052,0.636548,0.464838}},{{0.532747,-1.436236,-0.900262,-0.697533},{0.566295,0.650852,0.871414,-0.566183},{-0.075736,-0.886402,0.245348,-0.438080},{-0.811976,0.022233,-0.685647,0.323351}},{{-1.864578,1.141054,1.636157,-0.455965},{0.592333,0.890900,-0.259255,0.702826},{0.404528,0.905776,0.917764,0.051214},{0.761990,0.766907,-0.595618,-0.558207}}},{{{0.209262,-1.126957,-0.517694,-0.875215},{0.264791,0.338225,0.551586,0.505277},{0.183185,0.782227,0.888956,0.687343},{0.271838,0.125254,1.071891,-0.849511}},{{0.261293,-0.445399,0.170976,-0.401571},{0.801811,0.045041,-0.990778,-0.013705},{-0.343000,-0.913162,0.840992,0.551525},{-0.526818,-0.231089,0.085968,0.861459}},{{0.540677,-0.844281,-0.888770,0.438555},{0.802355,-0.825937,0.472974,-0.719263},{-0.648519,1.281454,0.470129,-0.538160},{-0.851015,0.985721,-0.993719,0.558735}},{{1.164560,-0.302101,0.953803,0.277318},{0.886169,0.623929,1.274299,-0.559466},{-0.948670,0.807814,-1.586962,-0.502652},{-0.069760,1.387864,-0.423140,0.285045}}}},
    {{{{0.747424,-0.044005,0.402212,-0.027484},{0.785297,0.169685,0.734339,-0.984272},{-0.656865,-1.397558,0.935961,-0.490159},{-0.099856,-0.293917,0.129296,-0.920536}},{{0.546529,-0.488280,-0.516120,-1.112775},{0.155881,-0.103160,0.187689,0.485805},{0.918357,0.829929,0.619437,0.877277},{0.389621,0.360045,0.434281,0.456462}},{{-0.803458,-0.525248,-0.467349,0.714159},{-0.648302,-0.005998,-0.812863,0.205664},{0.591453,0.653762,-0.227193,-0.946375},{0.080461,0.311794,0.802115,-1.115836}},{{-0.495051,-0.869153,-0.179932,0.925227},{-1.950445,1.908723,-0.378323,-0.472620},{-0.688403,-1.470251,1.991375,-1.698926},{-0.955808,-0.260230,0.319449,-1.368107}}},{{{-0.029073,-0.622921,-1.095426,-0.764465},{-0.362713,-0.123863,0.234856,-0.772613},{0.697097,0.103340,0.831709,0.529785},{0.103735,-0.526333,-0.084778,0.696831}},{{-0.670775,0.289993,-0.082204,-1.489529},{0.336070,0.322759,0.613241,0.743160},{0.298744,-1.193191,0.848769,-0.736213},{0.472611,-0.830342,0.437290,-0.467557}},{{-0.529196,-0.245683,0.809606,-0.956047},{-1.725613,0.187572,0.528054,-0.996271},{-0.330207,0.206237,0.218373,0.187079},{0.243388,0.625787,-0.388859,0.439888}},{{-0.802928,-0.811282,0.788538,0.948829},{0.966371,1.316717,0.004928,0.832735},{-0.226313,0.364653,0.724902,-0.579910},{-0.544782,-0.143865,0.069256,-0.020610}}},{{{-0.393249,0.671239,-0.481891,0.861149},{-0.662027,-0.693554,-0.564079,-0.477654},{0.070920,-0.052125,-0.059709,0.473953},{-0.280146,-0.418355,0.703337,0.981932}},{{-0.676855,0.102765,-0.832902,-0.590961},{1.717802,0.516057,-0.625379,-0.743204},{-0.170791,-0.813844,-0.269250,0.707447},{0.057623,0.472053,-0.211435,0.147894}},{{-0.298217,0.577550,1.845773,0.876933},{0.617987,0.502801,0.951405,0.122180},{0.924724,-0.166798,0.632685,-0.466165},{-0.834315,-0.864180,-0.274019,0.568493}},{{0.669850,-0.961671,0.790462,0.738113},{-0.534215,-0.556158,0.653896,0.031419},{0.065819,0.220394,0.153365,-0.373006},{0.886610,-0.742343,1.282099,0.198137}}},{{{0.092579,-0.026559,-1.121547,0.143613},{-0.289030,0.265226,-0.350741,-0.897469},{-0.918046,0.038521,-1.515900,0.488701},{-0.759326,-1.782885,-1.787784,0.249131}},{{-0.849816,-0.857074,-0.843467,-0.153686},{0.998653,0.356216,0.926775,0.300663},{-0.749890,-0.003425,-0.607109,0.317334},{-0.561644,0.446478,-0.898901,0.711265}},{{0.232020,-0.445016,0.618918,0.162098},{0.381030,-0.036170,0.084177,0.766972},{0.493139,0.189652,-0.511946,-0.273525},{0.863772,-0.586968,0.829531,-0.075552}},{{0.191787,-0.627198,0.975013,-0.448483},{-0.197885,0.151927,-0.558646,-1.308541},{-0.582967,1.207841,0.746132,0.245631},{0.314827,-0.702463,-0.301494,0.787569}}}},
    {{{{0.670028,-1.825749,-0.739187,0.482428},{0.175521,-0.020120,-0.154805,0.187004},{0.971728,-0.160181,-0.164031,-0.868147},{-0.954732,-0.175713,0.791116,0.294173}},{{-0.958337,-0.843157,-0.472882,0.273517},{-0.999058,0.824762,-0.223130,-0.150628},{0.393747,-0.301297,0.095572,-0.798950},{-0.119787,0.746673,0.955094,0.259353}},{{0.951590,0.225539,0.503282,0.668746},{-0.384898,-0.979592,-0.005485,-0.191883},{-0.692369,-0.642401,-0.825598,0.171933},{-0.321919,-0.498635,0.449704,0.780842}},{{-0.387902,0.522435,0.565608,0.166193},{-0.799671,-0.295871,-0.702573,-0.151006},{0.040550,-0.468503,0.651076,0.636352},{-0.839299,-0.090651,0.428761,0.187043}}},{{{-0.369823,0.377011,0.422936,0.284752},{-0.181514,-0.701449,0.748768,0.540533},{0.734381,0.149410,-0.867043,-0.397142},{-0.770904,-0.581897,-1.578306,-0.402638}},{{0.859015,-0.540358,0.202715,-0.975354},{-0.773629,-0.382342,-0.022498,-0.129286},{-0.901210,-0.641866,1.219216,0.731525},{0.740457,0.858546,-0.408661,-0.364897}},{{-0.830865,-1.370657,-1.226303,-0.392147},{-0.810554,-0.975232,-0.717845,-0.825379},{-0.150096,-0.664533,0.347084,0.243443},{-0.447383,0.842164,1.491342,0.380295}},{{-0.383958,0.811219,0.160459,0.841601},{1.631515,0.371637,0.110000,0.467783},{-0.689356,-0.004289,-0.081057,-0.317243},{0.092451,-0.181268,-0.575747,-0.580061}}},{{{0.908549,-0.013975,-0.880165,-0.938937},{-0.225713,0.449478,0.372569,-0.229889},{0.255711,-0.264752,0.307982,0.260505},{0.314966,-0.540905,0.743032,-0.078475}},{{-0.307472,-1.268296,0.020383,1.798401},{-0.150954,0.909716,-0.407903,0.379046},{0.621853,-0.003629,-0.582697,0.614618},{-0.122843,-0.627133,-0.217968,0.608322}},{{0.071923,0.807315,0.538905,-0.630660},{0.495641,0.240202,-0.920822,-0.258533},{-1.760363,-0.448525,-0.351553,-0.551666},{0.152720,0.900531,0.061966,-0.544377}},{{0.648923,0.450945,-1.530020,1.570190},{0.536210,0.078454,0.577168,0.464872},{-0.888258,-0.950748,0.781474,0.958593},{0.463631,0.319614,-0.248374,-0.413144}}},{{{0.293463,0.236284,1.721511,0.107408},{-0.790508,-0.072027,-0.559467,-0.955839},{-0.777662,-0.169876,0.896220,0.776105},{0.003944,-0.745496,-0.236446,-0.824604}},{{-1.770746,-0.051266,-0.174258,0.003074},{-0.339553,-0.868807,-0.032754,-0.494847},{-0.896712,0.957339,-0.003444,-1.582125},{-0.699883,0.626691,0.799635,-0.542343}},{{-0.635123,-0.755960,0.576373,-0.899530},{-0.393745,0.718900,0.312400,0.511415},{-0.647565,0.368431,0.214726,0.892693},{-0.511960,-0.513262,0.885908,-0.536478}},{{-0.590074,0.623328,0.268674,-0.401391},{0.308868,-0.869862,0.233132,0.243337},{-0.242908,-0.557192,-0.728454,0.867029},{0.156435,-0.805308,-0.815392,-1.437798}}}},
    {{{{0.613484,1.454566,-0.363858,0.634053},{0.535096,-0.641079,-0.607553,0.852559},{0.959100,-0.398621,0.375819,0.385756},{-0.601982,0.494128,0.809699,0.608804}},{{-1.390871,-0.943062,1.556671,0.966501},{-0.013242,0.152716,-0.089592,0.230793},{0.933785,0.119358,0.057387,0.502033},{-0.332925,0.537509,-0.081436,-0.701995}},{{-0.435117,0.996885,0.646630,-0.092342},{0.004343,-0.737514,-0.716187,-0.946819},{0.814258,-0.766971,-0.488162,-0.531619},{-0.923069,0.683915,-0.023809,-1.242992}},{{-0.909155,-0.166488,-0.159273,-0.908121},{-0.783871,-0.522598,0.691845,-0.164065},{1.255966,0.051373,-0.566025,0.820081},{0.186583,0.266032,-0.793747,-0.510092}}},{{{0.890639,0.970042,-0.507885,-0.029557},{-0.771142,-0.875802,0.400070,-1.264247},{-0.881146,0.570950,-0.051624,0.347612},{0.312110,-0.374885,0.600112,0.388460}},{{-0.417107,-0.309284,-0.128477,0.689671},{-0.695866,1.254585,-0.381883,-0.313415},{0.433565,0.919626,0.159180,-0.657310},{-1.396139,0.346053,0.108768,0.061238}},{{-0.776695,0.084491,0.045357,0.312823},{-0.379268,1.217006,-0.014838,-1.032272},{-1.251344,-0.366283,-0.124786,0.729754},{0.979936,0.669519,-0.900018,-0.596954}},{{-0.998834,0.593942,0.375639,-0.627459},{0.297281,0.400240,0.839707,0.960262},{-0.872143,0.574040,-0.559580,-1.965570},{-0.559218,-0.778780,-0.955526,-0.253380}}},{{{-1.919625,-1.911049,0.025035,0.754917},{-0.110993,0.535933,-0.572788,-0.856476},{-0.810836,-0.496261,1.128368,1.758826},{-0.564368,-1.849772,-0.251560,0.635528}},{{0.768196,-0.934122,0.207228,0.884610},{-0.356145,0.265792,-0.835582,0.377675},{-0.410745,0.613212,0.245560,-0.873826},{1.725191,-0.263344,-0.077167,-0.976379}},{{-0.736299,-0.109476,0.044512,-0.004005},{0.692230,0.316670,0.267247,-1.076821},{-0.903184,0.189762,-0.674111,0.219113},{0.639162,1.347521,0.428823,-0.765664}},{{-0.509165,0.458806,-0.851011,0.455027},{-0.218564,-0.063492,0.889320,-0.762062},{0.145950,0.985037,-0.489372,-0.879851},{0.352346,-0.127275,0.896496,-0.596037}}},{{{0.402678,1.479855,0.089187,0.967153},{-0.431225,0.402980,0.883584,-0.900324},{0.262233,-0.647278,0.637005,0.142678},{-0.003253,-0.671924,0.969458,-0.316752}},{{0.345185,-0.477503,-0.326822,-0.106251},{0.239521,1.617125,0.632651,0.969976},{-1.015183,-0.676629,0.955842,0.134925},{-0.319063,-0.493157,-0.488088,0.713008}},{{-0.468621,1.301292,-1.826501,1.138666},{0.170247,-0.661171,0.895204,-0.400700},{-0.077645,-0.978179,-0.245724,0.245282},{-0.258300,0.287261,-0.006274,0.549716}},{{-0.932247,-0.274950,0.920451,0.016237},{0.888865,-0.845248,1.661716,-0.108960},{0.712357,0.586609,-0.867356,0.355058},{-0.540912,0.892622,0.302627,0.247194}}}},
    {{{{0.817578,0.719047,0.438903,0.637398},{0.750466,-0.911799,-0.609606,0.358541},{-1.782979,-0.851717,-0.802122,0.735913},{0.490604,-0.417822,-0.332074,0.836756}},{{-0.650232,-0.442026,0.874916,0.705671},{0.217602,-0.755841,0.573944,0.279365},{-0.713729,0.358880,-0.308992,0.778297},{0.832099,-0.916695,-0.887834,1.041483}},{{1.019467,1.099488,-0.130674,-0.241995},{0.792572,0.756977,0.518186,0.070411},{-0.815779,-0.790757,-1.027439,-0.163698},{0.721461,-0.403364,0.656609,-0.367364}},{{-0.279333,-0.742041,0.515832,-0.408114},{0.834577,0.736056,0.900594,0.276357},{0.726000,0.464991,-0.569281,0.098139},{-0.582324,0.875666,-0.681556,-0.903009}}},{{{1.300969,-0.798351,0.107230,1.611284},{0.239211,0.418231,-0.795764,-0.398818},{-0.939666,1.768175,-0.297023,-0.064087},{-0.239119,-0.365132,0.864138,0.595560}},{{1.898313,-0.343816,1.066256,0.876655},{-0.053636,0.544756,-0.937927,0.189233},{0.445371,-0.656790,-0.675091,0.753163},{-0.293330,-0.002717,0.341173,0.095493}},{{0.951658,0.513912,-0.678347,-0.981140},{-0.020791,0.571138,-0.890648,0.881789},{-1.783345,0.909598,-0.393155,0.240630},{-0.057908,-0.237435,-0.124993,-0.754091}},{{-0.014153,0.127172,0.097134,0.538952},{0.167943,0.786395,0.946153,-0.762513},{-0.562758,0.675657,-0.226395,0.979761},{0.850214,0.818309,0.397074,-0.372059}}},{{{0.803316,-0.659538,-1.987864,-0.186366},{-0.259213,0.315848,-0.427898,0.326521},{-0.168181,-0.620898,0.562309,0.722064},{-1.949690,0.307720,-0.147760,0.603492}},{{0.898339,0.986228,0.724530,0.105193},{0.066046,0.037689,-0.553543,0.597864},{0.296553,0.165199,0.500125,-0.395978},{0.790120,-1.873361,0.354841,-0.187812}},{{-0.559746,0.357012,0.373903,-0.113564},{-0.671918,-0.919720,0.258328,-0.283453},{0.008365,0.597272,0.355827,0.391287},{0.355297,-0.631888,0.221383,1.448221}},{{0.259199,-0.491776,0.721151,0.391427},{0.494000,0.652814,-0.153306,-0.615687},{0.142167,-0.601161,0.281702,0.563390},{0.904019,1.284241,0.901663,0.244620}}},{{{-0.664638,-0.564596,0.839897,0.153358},{-0.506883,0.822337,-0.974957,-0.098112},{-0.962870,-0.274566,0.418039,-0.020525},{-0.965969,0.954587,-0.250493,-0.031592}},{{-0.966475,0.455338,0.868491,0.723032},{-0.002141,0.021922,-0.131429,-0.601106},{-1.240003,1.483318,1.612920,-0.653210},{-0.505979,0.005588,-0.087506,-0.705789}},{{-0.203137,0.765652,-0.132974,-0.900534},{0.731132,0.133467,-1.086363,0.600763},{1.795911,-0.411613,-1.990494,0.405937},{0.729332,-0.119175,-0.979213,0.362346}},{{-0.049014,0.228577,-1.728796,-0.898348},{-0.540969,1.245881,-0.820859,0.285859},{0.430751,-0.373652,0.034535,0.434466},{0.365354,0.243261,0.910114,1.497873}}}}
};
float eval_polynomial(float variables[4],int program_index,int variable_index,int indices[4]){
    if(variable_index==4)return program[program_index][indices[0]][indices[1]][indices[2]][indices[3]];
    float result=0,base=1;
    for(int power=0;power<4;++power){
        indices[variable_index]=power;
        result+=base*eval_polynomial(variables,program_index,variable_index+1,indices);
        base*=variables[variable_index];
    }
    return result;
}
int main(int argc,char *argv[]){
    srand(tick_count());
    rand();
    float variables[4],probability[5],total=0;
    int i,indices[4],temp;
    for(i=0;i<4;++i){
        sscanf(argv[i-4+argc],"%d",&temp);
        variables[i]=temp;
    }
    temp=variables[1];
    variables[1]=variables[2];
    variables[2]=temp;
    if(variables[1]==0){ //bow if our honour is 0
        putchar('B');
        return 0;
    }

    variables[0]/=20;variables[2]/=20;
    variables[1]=1/(variables[1]+1);variables[3]=1/(variables[3]+1);
    for(i=0;i<5;++i){
        probability[i]=eval_polynomial(variables,i,0,indices);
        if(probability[i]<0)probability[i]=0;
        total+=probability[i];
        probability[i]=total;
    }
    total*=(float)rand()/RAND_MAX;
    for(i=0;i<5;++i)if(total<probability[i]){
        putchar("BGIPO"[i]);
        return 0;
    }
    putchar('B');
    return 0;
}

[१] पूरी तरह से अप्रासंगिक संख्या [२] समय के १% सच होने की गारंटी

YAGMCSE

मोंटे कार्लो के तरीके सभ्य खेल का प्रदर्शन करते हैं, इसलिए यहाँ एक और जेनेरिक मोंटे कार्लो सिमुलेशन एंट्री है!

इस प्रतियोगिता में अन्य प्रविष्टियों के विपरीत, इस प्रविष्टि में यादृच्छिक खेलों के सिमुलेशन की एक बड़ी संख्या का उपयोग किया जाता है, और इस प्रकार इष्टतम प्रदर्शन के लिए -O3 ध्वज के उपयोग की आवश्यकता होती है।

कमांड के साथ प्रोग्राम को संकलित करें: gcc monte.c -o monte -O3 -std = c99

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#include <Windows.h>
unsigned int tick_count(){
    return GetTickCount();
}
#else
#include <sys/time.h>
unsigned int tick_count(){
    struct timeval t;
    gettimeofday(&t, NULL);
    return 1000 * t.tv_sec + t.tv_usec / 1000;
}
#endif

const int turn_limit=500;
enum Move{
    WAIT,BOW,GUARD,QUICK,PARRY,OVERHEAD
};
struct Player{
    int health,honour;
    enum Move lastMove;
};
typedef struct Player Player;
//<command> <history> <enemy_history> <your_health> <enemy_health> <your_honour> <enemy_honour>
//<command> <your_health> <enemy_health> <your_honour> <enemy_honour>
int damage_table[6][6][2]={
    {{0,0},{0,0},{0,0},{1,0},{1,0},{1,0}}, //P1 is waiting
    {{0,0},{0,0},{0,0},{1,0},{1,0},{1,0}}, //P1 is bowing
    {{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}}, //P1 is guarding
    {{0,1},{0,1},{0,0},{0,0},{1,0},{0,1}}, //P1 is using quick draw
    {{0,1},{0,1},{0,0},{0,1},{0,0},{1,0}}, //P1 is parrying
    {{0,1},{0,1},{0,0},{1,0},{0,1},{0,0}} //P1 is using overhead attack
};
enum Move decode_move(char x){
    switch(x){
        case 'W': return WAIT; break;
        case 'B': return BOW; break;
        case 'G': return GUARD; break;
        case 'I': return QUICK; break;
        case 'P': return PARRY; break;
        case 'O': return OVERHEAD; break;
    }
    return WAIT;
}
struct SimulationStat{
    enum Move first_me_move;
    int win,draw,lose,compound;
};
int stat_compare(const void*a,const void*b){
    return ((struct SimulationStat*)b)->compound-((struct SimulationStat*)a)->compound;
}
struct SimulationStat monte_carlo(int num_iters,enum Move first_me_move,Player original_me,Player original_opponent){
    struct SimulationStat simulation_result={first_me_move,0,0,0};

    for(int iter=0;iter<num_iters;++iter){
    Player me=original_me,opponent=original_opponent;
        int turn,game_result;
        for(turn=0;turn<turn_limit;++turn){
            enum Move me_move,opponent_move=rand()%(OVERHEAD-BOW+1)+BOW;
            if(turn==0)me_move=first_me_move;
            else me_move=rand()%(OVERHEAD-BOW+1)+BOW;

            //update honour for guarding
            if(me.lastMove==GUARD&&me_move==GUARD)--me.honour;
            if(opponent.lastMove==GUARD&&opponent_move==GUARD)--opponent.honour;

            int me_attacking=me_move==QUICK||me_move==PARRY||me_move==OVERHEAD,opponent_attacking=opponent_move==QUICK||opponent_move==PARRY||opponent_move==OVERHEAD;

            //update health of players
            me.health-=damage_table[me_move][opponent_move][0]*(1+(opponent.honour>=7));
            opponent.health-=damage_table[me_move][opponent_move][1]*(1+(me.honour>=7));

            //update honour for attacking (Sword of the Gods is revoked after the player attacks with an original honour value of 7)
            if(me_attacking)--me.honour;
            if(opponent_attacking)--opponent.honour;

            //printf("%d %d\n",me.health,me.honour);
            //printf("%d %d\n",opponent.health,opponent.honour);

            //check if any of the terminating conditions are met
            //c. both players fall off the graces of the gods (me.honour<0&&opponent.honour<0)
            if(me.honour<0&&opponent.honour<0){
                game_result=0; //draw
                break;
            }
            //a. player 1 falls off the graces of the gods (me.honour<0)
            else if(me.honour<0){
                game_result=-1; //loss
                break;
            }
            //b. player 2 falls off the graces of the gods (opponent.honour<0)
            else if(opponent.honour<0){
                game_result=1; //win
                break;
            }
            //d. both players are dead (me.health<0&&opponent.health<0)
            else if(me.health<0&&opponent.health<0){
                game_result=0; //draw
                break;
            }
            //e. player 1 is dead (me.health<0)
            else if(me.health<0){
                game_result=-1; //loss
                break;
            }
            //f. player 2 is dead (opponent.health<0)
            else if(opponent.health<0){
                game_result=1; //win
                break;
            }
        }
        //both players get struck down by the guards for being boring
        if(turn==turn_limit)game_result=0; //draw

        if(game_result==1)++simulation_result.win;
        else if(game_result==0)++simulation_result.draw;
        else ++simulation_result.lose;
    }
    return simulation_result;
}
int main(int argc,char*argv[]){
    //const int num_iters=200000,num_shortlist_iters=1000000;
    const int num_iters=20000,num_shortlist_iters=55000;

    srand(tick_count());
    Player me,opponent;
    if(argc==5){
        sscanf(argv[1],"%d",&me.health);
        sscanf(argv[2],"%d",&opponent.health);
        sscanf(argv[3],"%d",&me.honour);
        sscanf(argv[4],"%d",&opponent.honour);
        me.lastMove=WAIT;
        opponent.lastMove=WAIT;
    }else{
        sscanf(argv[3],"%d",&me.health);
        sscanf(argv[4],"%d",&opponent.health);
        sscanf(argv[5],"%d",&me.honour);
        sscanf(argv[6],"%d",&opponent.honour);
        me.lastMove=decode_move(argv[1][strlen(argv[1])-1]);
        opponent.lastMove=decode_move(argv[2][strlen(argv[2])-1]);
    }

    struct SimulationStat results[6];
    results[0].first_me_move=WAIT;
    results[0].win=0;
    results[0].draw=0;
    results[0].lose=num_iters;
    results[0].compound=-num_iters*2-1000; //waiting is worse than any other action

    for(enum Move first_me_move=BOW;first_me_move<=OVERHEAD;++first_me_move){
        results[first_me_move]=monte_carlo(num_iters,first_me_move,me,opponent);
        struct SimulationStat *cur=&results[first_me_move];
        cur->compound=cur->win*4+cur->draw*1-cur->lose*2;
    }
    qsort(results,OVERHEAD-WAIT+1,sizeof(*results),stat_compare);

    for(int i=0;i<OVERHEAD-BOW+1;++i){
        struct SimulationStat *cur=&results[i];
//        fprintf(stderr,"%c: %f%% win, %f%% draw, %f%% lose => %d\n","WBGIPO"[cur->first_me_move],(double)cur->win/num_iters*100.,(double)cur->draw/num_iters*100.,(double)cur->lose/num_iters*100.,cur->compound);
    }

    for(int i=0;i<2;++i){
        results[i]=monte_carlo(num_shortlist_iters,results[i].first_me_move,me,opponent);
        struct SimulationStat *cur=&results[i];
        cur->compound=cur->win*2+cur->draw*1;
    }
    qsort(results,2,sizeof(*results),stat_compare); 

    for(int i=0;i<2;++i){
        struct SimulationStat *cur=&results[i];
//        fprintf(stderr,"%c: %f%% win, %f%% draw, %f%% lose => %d\n","WBGIPO"[cur->first_me_move],(double)cur->win/num_shortlist_iters*100.,(double)cur->draw/num_shortlist_iters*100.,(double)cur->lose/num_shortlist_iters*100.,cur->compound);
    }
    putchar("WBGIPO"[results[0].first_me_move]);
    return 0;
}
— Potatomato
स्रोत
1
वह केवल जो भी कारण के लिए झुकना लगता है। आप इसे एक रूप देना चाह सकते हैं
— C5H8NNaO4
@ C5H8NNaO4 इस गंभीर बग के बारे में मुझे सूचित करने के लिए धन्यवाद। मेरा संपादन बग को ठीक करना चाहिए।
— पोटेटोमेटो
YAGMCSE केवल या तो करने के लिए लगता हैGBWWWWW...BWWWW
— C5H8NNOO4
@ C5H8NNaO4 यह अजीब है। मैंने आपके द्वारा बताए गए परिणामों को दोहराने में सक्षम नहीं है। क्या YAGMCSE का विरोधी सदा झुकने / रखवाली / प्रतीक्षा कर रहा था?
— पोटाटोमेटो
हां, वह पहले 7 राउंड को झुका रहा था। यहाँ एक है pastebin
— C5H8NNaO4
1

लक्ष्य डमी में प्रवेश करने के मेरे असफल प्रयास के बाद, मैं आपके सामने अपना अगला बॉट प्रस्तुत करता हूं ...

स्क्रूजबॉट - पायथन 2

यह बॉट झुकेगा यदि उसके पास एक सम्मान है। नहीं तो वह एक सिक्का फ्लिप करेगा।

यदि यह सिर पर उतरता है, तो वह एक यादृच्छिक हमला करेगा। यदि यह पूंछ पर उतरता है, तो वह या तो झुकेगा या गार्ड करेगा।

कमान: python scroogebot.py

import random, sys
# If he has more than one honor...
if int(sys.argv[5]) > 1:
    #Flip a coin.
    coin = random.choice(['heads','tails'])
    #If the coin lands on heads...
    if coin == 'heads':
        #Attack!
        print random.choice(['I','O','P'])
    #If the coin lands on tails...
    else:
        #Don't attack!
        print random.choice(['G','B'])
#If he has 1 honor...
else:
    #Bow!
    print "B"
— DJgamer98
स्रोत
याय, एक नई प्रविष्टि! बस एक त्वरित सिर - यह एक समय हो सकता है इससे पहले कि मैं एक नया टूर्नामेंट स्थापित कर सकूं, क्योंकि मैंने कल अपने ऑपरेटिंग सिस्टम को फिर से तैयार किया। हालांकि, सप्ताह के अंत तक मुझे आपके परिणामों के साथ एक नया टूर्नामेंट करना चाहिए।
— absinthe
0

योशिमित्सु (जेएस)

अंतिम दो चालों की जांच करके पहरा नहीं देने की कोशिश करने पर उच्च सम्मान के साथ बहादुरी मिलेगी। बनाया टेम्पलेट apsillers बंद

var attacks = ['I','P','O'];
var pasive = ['B','W'];
var argv = process.argv;
var playerHistory = argv.length>6?argv[2].split(''):[];
var enemyHistory = argv.length>6?argv[3].split(''):[];
var offset = 8 - argv.length;
var my = { health:+argv[4-offset], honor:+argv[6-offset], history:playerHistory };
var enemy = { health:+argv[5-offset], honor:+argv[7-offset], history:enemyHistory };
my.godSword = my.honor >= 7;
enemy.godSword = enemy.honor >= 7;

enemy.lastMove = enemyHistory.pop();
enemy.secondToLast = enemyHistory.pop();

enemy.didAttack = !!attacks.indexOf(enemy.lastMove);

my.lastMove = playerHistory.pop();

function decide() {
    process.stdout.write(arguments[Math.floor(arguments.length*Math.random())]);
    process.exit();
}

chooseAnAttack = function(){ decide.apply(this,attacks); };

if( ( pasive.indexOf( enemy.lastMove ) && my.honor < 15 ) || (my.honor < 7 && enemy.health > 10) || my.honor === 1 ){
    if( Math.random * 15 < my.honor ){
        chooseAnAttack();
    } else {
        decide('B');
    }
} else if( enemy.honor < 2 ){
    chooseAnAttack();
} else if( enemy.didAttack ){

    if( attacks.indexOf( enemy.secondToLast ) ){
        decide('G');
    } else if( pasive.indexOf( enemy.secondToLast ) ){
        chooseAnAttack();
    } else if( enemy.secondToLast == 'G' ){
        decide('B');
    }

} else if( enemy.lastMove = 'G' ) {
    chooseAnAttack();
} else if( enemy.lastMove === 'W' ){
    if( attacks.indexOf( enemy.secondToLast ) ){
        decide('G');
    } else if( pasive.indexOf( enemy.secondToLast ) ){
        chooseAnAttack();
    } else if( enemy.secondToLast == 'G' ){
        decide('B');
    }
}
— Gilsham
स्रोत
0

मूर्ख (C)

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

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

const char commands[] =
{
    'W', 'B', 'G', 'I', 'P', 'O'
};

char select_candidate(const char c[])
{
    unsigned i = 0;
    int n_candidates = 0;
    char candidates[sizeof(commands)];

    for (; i < sizeof(commands); i++)
        if (c[i])
            candidates[n_candidates++] = c[i];

    /* There are no candidates for actions, so the fool blindly attacks his opponent, hoping for the best */
    return n_candidates == 0 ? 'I' : candidates[rand() % n_candidates];
}

int main(int argc, char *argv[])
{
    unsigned i = 0;
    int honour;
    char candidates[sizeof(commands)];
    char last_action;

    srand(time(NULL));

    memcpy(candidates, commands, sizeof(commands));

    /* It's the first round, the fool selects a random action except for waiting */
    if (argc != 7)
    {
        candidates[0] = 0;
        putchar(select_candidate(candidates));
        return 0;
    }

    last_action = argv[1][strlen(argv[1]) - 1];
    honour = atoi(argv[5]);

    if (honour == 0)
    {
        /* The fool realises he will meet his doom if he performs any of the following moves */
        /* and removes them from his list of possible actions */
        candidates[3] = 0;
        candidates[4] = 0;
        candidates[5] = 0;

        /* Only omit the blocking action if the last action was blocking */
        if (last_action == 'G')
            candidates[2] = 0;
    } else if (honour >= 7) {

        /* If the fool has the opportunity to abuse power, he will */
        candidates[0] = 0;
        candidates[1] = 0;
    }

    /* However unintellegent, the fool decides never to repeat the same move twice */
    for (; i < sizeof(commands); i++)
    {
        if (candidates[i] == last_action)
        candidates[i] = 0;
    }

    /* The fool randomly selects a possible action and hopes for the best */
    putchar(select_candidate(candidates));

    return 0;
}

पैगंबर (सी)

पैगंबर अपने प्रतिद्वंद्वी की पिछली 2 चालों के ज्ञान का उपयोग करता है ताकि वह अपनी अगली चाल की भविष्यवाणी कर सके और एक तेज और घातक जवाबी हमला कर सके। इसके अलावा, वह ज्योतिष और सामान भी करता है।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

int main(int argc, char* argv[])
{
    char* hist;
    char* enemy_hist;
    int hist_len;
    int enemy_hist_len;
    int health;
    int enemy_health;
    int honour;
    int enemy_honour;

    if (argc != 7)
    {
        /* Always start with guarding */
        putchar('G');
        return 0;
    }

    srand(time(NULL));

    /* Grab the command-line values */
    hist         = argv[1];
    enemy_hist   = argv[2];
    health       = atoi(argv[3]);
    enemy_health = atoi(argv[4]);
    honour       = atoi(argv[5]);
    enemy_honour = atoi(argv[6]);

    hist_len = strlen(hist);
    enemy_hist_len = strlen(enemy_hist);

    /* Looks like the enemy is starving for honour. */
    /* This means that they have to bow, so attack them,  */
    /* But only if we have the honour to do so. */
    if (enemy_honour == 0 && honour > 0)
    {
        putchar('O');
        return 0;
    } else if (honour == 0) {
        /* We have to bow */
        putchar('B');
        return 0;
    } else if (honour <= 3) {
        /* We have low honour, attack if the enemy has no honour, otherwise bow to restore some of our honour */
        putchar(enemy_honour == 0 ? ((rand() % 2) ? 'I' : 'O') : 'B');
        return 0;
    }

    switch (enemy_hist[enemy_hist_len - 1])
    {
        /* The enemy has previously performed a passive action, so they will likely attack this round */
        case 'W':
        case 'B':
        case 'G':
            putchar(hist[hist_len - 1] == 'G' ? 'P' : 'G'); /* Protect ourselves, using `guard` if we did not use it last turn */
            return 0;

        default:
            if (enemy_hist_len >= 2)
            {
                switch (enemy_hist[enemy_hist_len - 2])
                {
                    case 'I':
                    case 'P':
                    case 'O':
                        /* The enemy has attacked for the last 2 turns, they will likely rest now */
                        putchar((rand() % 2) ? 'I' : 'O');
                        return 0;

                    default:
                        /* Low health, block an incoming attack */
                        if (health <= 5)
                        {
                            putchar(hist[hist_len - 1] == 'G' ? 'P' : 'G');
                            return 0;
                        } else {
                            /* Choose randomly to bow or attack */
                            int decision = rand() % 3;
                            putchar(decision == 2 ? 'B' : decision == 1 ? 'I' : 'O');
                            return 0;
                        }
                }
            } else {
                /* Attack! */
                putchar((rand() % 2) ? 'I' : 'O');
                return 0;
            }
    }

    /* If somehow we get to this point, parry */
    putchar('P');
    return 0;
}

संकलन

दोनों कार्यक्रम सी में लिखे गए हैं, और इनके साथ संकलित किया जा सकता है gcc:

gcc fool.c -o fool
gcc prophet.c -o prophet

चल रहा है

* nix

./fool <args>
./prophet <args>

विंडोज

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