कोडनेम, मैं आपको चुनता हूं!

Question

आपका दयालु पड़ोसी, डॉक्टर ट्री, बस आपको तीन जादुई जीव दिए गए हैं जिन्हें कोडमोन कहा जाता है। पास के शहर कलरविले में एक लड़ाई टूर्नामेंट है। क्या आप बहुत अच्छे हैं, जैसे कोई कभी नहीं था?

अवलोकन

यह एक लड़ाई टूर्नामेंट है। प्रत्येक खिलाड़ी तीन राक्षसों की एक टीम को नियंत्रित करता है, और उद्देश्य दूसरी टीम को मारना (मारना) है। 100 राउंड हैं, जिसमें जीत और संबंधों के लिए अंक दिए जाते हैं। सबसे अधिक अंक जीतने वाली टीम!

दानव

कोडेक्स एक जटिल छोटा जीव है। चुनने के लिए पांच प्रकार (तत्व) हैं, तीन आँकड़े, और प्रत्येक पर तीन चाल स्लॉट।

प्रकार

प्रत्येक कोडनेम को एक प्रकार सौंपा गया है । पांच प्रकार सामान्य, मानसिक, अग्नि, जल और घास हैं। प्रत्येक की अपनी ताकत और कमजोरियां हैं। नुकसान निम्नलिखित चार्ट पर आधारित है:

संख्या क्षति गुणक हैं। उदाहरण के लिए, फायर अटैकिंग वॉटर में 0.5 मॉडिफायर (आधी क्षति) होती है, जबकि फायर अटैकिंग ग्रास दोगुना (2) होता है।

आँकड़े

प्रत्येक राक्षस के पास तीन आँकड़े होते हैं जो उसकी युद्ध क्षमताओं को निर्धारित करते हैं। हमला इससे होने वाले नुकसान को उठाता है। रक्षा नुकसान को कम करती है। स्पीड इसे कम स्पीड वाले लोगों के सामने ले जाने की अनुमति देती है।

प्रत्येक राक्षस के पास प्रत्येक स्टेट के लिए 50 का शुरुआती मूल्य है, और अधिकतम 100 है। जब आप अपने राक्षसों का निर्माण करते हैं, तो आप 80 अतिरिक्त स्टेट पॉइंट (प्रत्येक) असाइन कर पाएंगे । याद रखें कि कोई भी व्यक्तिगत प्रतिमा 100 से अधिक नहीं जा सकती है। इसलिए, आपके पास 100/80/50, 90/80/60 या 65/65/100 वितरण हो सकता है, लेकिन 120/50/60 अवैध है। अवैध आँकड़ों वाली कोई भी टीम अयोग्य है। आपको सभी 80 बिंदुओं का उपयोग करने की आवश्यकता नहीं है , लेकिन संभवतः आपको न्यूनतम 50/50/50 के साथ नहीं जाना चाहिए।

आप HP को एक स्टेटस भी मान सकते हैं, लेकिन प्रत्येक कोडनेम में एक गैर-परिवर्तनीय 100 HP है। जब एचपी शून्य तक गिर जाता है, तो वे लड़ाई जारी रखने में असमर्थ होते हैं। एचपी को प्रत्येक लड़ाई से पहले 100 तक रिफिल किया जाता है।

चालें

प्रत्येक राक्षस तीन लड़ाई चाल जानता है। चुने गए तीन अलग-अलग होने चाहिए, इसलिए कोई पंच / पंच / पंच न हो।

15 चालें हैं, प्रत्येक प्रकार के तीन। प्रत्येक प्रकार में एक सीधा हमला, एक प्रभाव के साथ एक कमजोर हमला, और एकमात्र प्रभाव चाल है।

id  name        type    power   uses    usable  effect

0   Punch       N       20      -       NFWG
1   Heal        N        0      3       NFWG    Heals 50 HP
2   Slow        N       10      5       NFWG    Enemy speed x0.8
3   Pain        P       20      -       PFWG
4   Sleep       P        0      3       PFWG    No enemy action until wake
5   Weaken      P       10      5       PFWG    Enemy Atk x0.8
6   Fireball    F       20      -       NPFW
7   Burn        F        0      3       NPFW    Enemy -10 HP each turn
8   Sharpen     F       10      5       NPFW    Own Atk x1.25
9   Watergun    W       20      -       NPWG    
10  Confuse     W        0      3       NPWG    Enemy may strike itself (10 power)
11  Shield      W       10      5       NPWG    Own Def x1.25
12  Vine        G       20      -       NPFG
13  Poison      G        0      3       NPFG    Enemy -5xTurns HP each turn
14  Sap         G       10      5       NPFG    Enemy Def x0.8

typeचाल के प्रकार को संदर्भित करता है। powerइसकी हड़ताली शक्ति है। usesइंगित करता है कि इसे प्रति युद्ध कितनी बार इस्तेमाल किया जा सकता है ( -असीमित है)। usableदिखाता है कि इसका किस प्रकार से उपयोग किया जा सकता है (उदाहरण के लिए, पंच मानसिक प्रकार को नहीं दिया जा सकता है, क्योंकि वहाँ नहीं है P)। effectदिखाता है कि चालों का क्या प्रभाव पड़ता है। हील को छोड़कर प्रत्येक प्रभाव में 75% काम करने की संभावना है, जो हमेशा काम करता है।

एक राक्षस के आँकड़े बदलने वाले प्रभावों के लिए, प्रभावों को स्टैक किया जा सकता है । उदाहरण के लिए, दो बार वीकेन का उपयोग करने से आपके प्रतिद्वंद्वी का हमला 0.64 प्रभावशीलता तक कम हो सकता है। प्रभाव जो एक राक्षस के आँकड़े नहीं बदलते हैं (नींद, जला, आदि) स्टैक नहीं करते हैं ।

नींद प्रतिद्वंद्वी को नींद में डाल देती है, प्रत्येक मोड़ की शुरुआत में 60% जागने की संभावना होती है। सोने वाले राक्षसों द्वारा कोई कार्रवाई नहीं की जाएगी।

जला नुकसान प्रतिद्वंद्वी 10 अश्वशक्ति प्रत्येक बारी के अंत में जब सक्रिय । जहर समान रूप से काम करता है, लेकिन प्रत्येक मोड़ में बढ़ती मात्रा लेता है। पहले मोड़ पर, यह 5 है, और इसके बाद प्रत्येक 5 मोड़ हैं। तो, चौथी बारी से, यह 20 के लिए हानिकारक होगा। ये फ्लैट क्षति हैं, जो राक्षस के प्रकार या बोनस के अधीन नहीं हैं।

भ्रम एक राक्षस पर हमला कर सकता है बजाय इसके कि वह क्या करने के लिए कहा गया था। इस हमले में शक्ति 10 है, और किसी दिए गए मोड़ पर होने का 30% मौका है।

स्पष्ट होने के लिए, प्रभाव लड़ाई के अंत तक रहता है (नींद को छोड़कर, जैसा कि ऊपर उल्लेख किया गया है)।

अगर इसी प्रकार के राक्षस द्वारा उपयोग किया जाता है, तो मूव्स को 20% की शक्ति मिलती है। उदाहरण के लिए, वाइन का उपयोग करने वाले एक घास राक्षस को बढ़ावा दिया जाता है, जबकि पंच का उपयोग करते हुए वह नहीं है।

गुप्त आँकड़े

प्रत्येक राक्षस के आँकड़े और प्रकार (लेकिन नहीं चलते हैं) सार्वजनिक ज्ञान है। आपके विरोधी यह देखने में सक्षम होंगे कि वे क्या लड़ रहे हैं, ताकि सर्वश्रेष्ठ कार्रवाई चुन सकें। हालांकि, वहाँ भी बोनस उपलब्ध हैं जो छिपे हुए हैं।

विशेष रूप से, हर दो लड़ाइयों के बाद , आपको अपनी टीम के प्रत्येक राक्षस के लिए एक "बोनस" स्टेट पॉइंट दिया जाएगा। अंक सभी राक्षसों, मृत या जीवित, विजेता या हारे हुए को दिए जाते हैं। आप इसे अपने द्वारा चुने गए तीन आँकड़ों में से किसे भी असाइन कर सकते हैं। आप उन्हें एक राक्षस पर ढेर नहीं कर सकते; प्रत्येक राक्षस को हर बार एक मिलता है । ये बिंदु 100 सीमा तक प्रतिरक्षा हैं। चूंकि 100 राउंड राउंड होंगे, इसका मतलब है कि आप 149 तक एक सिंगल स्टैट प्राप्त कर सकते हैं यदि आप इसे अपने सभी बोनस आवंटित करते हैं। फिर, प्रतिद्वंद्वी को केवल आपके "आधार" आँकड़े दिखाई देंगे, इसलिए आप जितने टूर्नामेंट में आगे बढ़ेंगे, उतना ही उनका ज्ञान सच्चाई से अलग होगा।

लड़ाई

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

उसके बाद, निम्न चरणों के साथ परिवर्तन होता है:

• स्विच: अनिवार्य राक्षस स्विच जगह लेता है (यदि कोई हो)
• लड़ाई कार्रवाई चुनें
• स्विच: किसी भी वैकल्पिक राक्षस स्विच (लड़ाई कार्रवाई के रूप में चुना गया) को जगह मिलती है
• नींद की जाँच करें: नींद से जागने का मौका
• हमला 1: यदि सक्षम है, तो गतिमान राक्षस अपनी चयनित चाल का उपयोग करता है
• हमला 2: यदि सक्षम है, तो दूसरा राक्षस अपनी चयनित चाल का उपयोग करता है
• प्रभाव क्षति: जीवित राक्षसों को जला / जहर क्षति लागू करें

"स्पीडियर" का अर्थ है उच्च गति वाला राक्षस। यदि दोनों गति आँकड़े समान हैं, तो इसे प्रत्येक मोड़ पर PRNG सिक्का फ्लिप द्वारा चुना जाता है।

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

निष्क्रिय होने पर राक्षस "संसाधित" नहीं होते हैं। इसका मतलब है कि वे कोई जहर / जहर क्षति नहीं लेते हैं, जहर काउंटर जमा नहीं करेंगे, नींद से कोई जगा नहीं आदि । स्विच करते समय कोई प्रभाव नहीं हटाया जाता है या बदल दिया जाता है । ऐसा नहीं है कि अन्य राक्षस खेल से जूझ रहे हैं। यदि आप उठे और जलाए गए हमले के साथ बाहर निकलते हैं, तो जब आप वापस अंदर जाते हैं, तब भी वे वहीं रहेंगे।

प्रभाव क्षति होती है कि आप अपने सक्रिय प्रतिद्वंद्वी को मारते हैं या नहीं। इस तरह, दोनों टीमों के सदस्य एक ही मोड़ पर मर सकते हैं।

जब एक टीम बेकार राक्षसों से बाहर निकलती है, तो वे हार जाते हैं। यदि दोनों टीमें एक ही मोड़ पर बाहर जाती हैं, तो यह एक टाई है। यदि लड़ाई 1000 के लिए रहती है, तो यह एक टाई है।

क्षति का निर्धारण करने का सूत्र है:

floor((effAttack / effDefense) * movePower * typeMultiplier * moveBoost)

effAttackऔर effDefenseकर रहे हैं प्रभावी राक्षसों के लिए आँकड़े। हमला और बोनस हमला जोड़कर प्रभावी आक्रमण प्राप्त किया जाता है, फिर यदि कोई प्रभाव इसे बदलता है तो (0.8 या 1.25 से गुणा)। याद रखें कि ये प्रभाव ढेर हो सकते हैं।

नुकसान केवल 0 हो सकता है जब प्रकार संशोधक 0 (सामान्य <-> मानसिक) या चाल की शक्ति 0 (चंगा, जला, आदि) है। अन्यथा न्यूनतम 1 पर लागू किया जाता है।

टूर्नामेंट

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

यदि टीमों को बांध दिया जाता है, तो टाईब्रेकर ऑर्डर निर्धारित करने के लिए केवल पहले स्थान पर रहने वाली टीमों के साथ एक टूर्नामेंट होगा।

मसविदा बनाना

कंट्रोलर आपके प्रोग्राम को चार कमांड में से एक भेजेगा। यदि आवश्यक हो, तो पहला वर्ण डेटा टाइप के साथ कमांड प्रकार को निर्धारित करता है।

आपका प्रोग्राम कमांड को एक तर्क के रूप में स्वीकार करेगा, और एक सेकंड के भीतर STDOUT पर प्रतिक्रिया देगा । STDIN को सुनकर जिंदा न रहें, ऐसा नहीं होगा। प्रत्येक कमांड एक नई प्रक्रिया शुरू करेगा।

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

आदेश

टीम डेटा

यह आपकी टीम को पंजीकृत करने के लिए टूर्नामेंट की शुरुआत में एक बार भेजा जाता है। आपका जवाब निरंतर होना चाहिए , प्रत्येक टूर्नामेंट के लिए अलग नहीं।

प्रश्न:

T

उत्तर:

name|member0|member1|member2

nameआपकी टीम के नाम के साथ एक स्ट्रिंग है। पार्सिंग में आसानी के लिए कृपया अल्फ़ान्यूमेरिक का उपयोग करें। memberNएक सदस्य स्ट्रिंग है, जो प्रत्येक राक्षस का विवरण देता है:

सदस्य स्ट्रिंग:

name:typeid:attack:defense:speed:moveid0:moveid1:moveid2

फिर, 'नाम' एक स्ट्रिंग है, इस बार इस राक्षस के नाम के साथ। typeidइसका प्रकार है। सामान्य आईडी 0 और ग्रास = 4 के साथ टाइप आईडी उपरोक्त चार्ट में दिखाए गए क्रम में हैं।

अगले तीन फ़ील्ड आपके आधार आँकड़े हैं। ऊपर दिए गए आंकड़े अनुभाग में वर्णित सीमाओं को ध्यान में रखें।

अंतिम तीन आपके राक्षस की चाल हैं। आईडी चाल चार्ट में ऊपर दिखाए गए हैं।

एक उदाहरण टीम डेटा उत्तर इस तरह दिख सकता है:

DummyTeam|DummyA:0:50:60:70:0:1:2|DummyB:0:50:60:70:0:1:2|DummyC:0:50:60:70:0:1:2

कोई भी टीम जो कचरा, बीमार-स्वरूपित, या अवैध डेटा वापस भेजती है, वह तब तक भाग नहीं लेगी, जब तक कि वह तय नहीं हो जाती।

सक्रिय चुनें

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

प्रश्न:

C#battleState

battleStateवर्तमान लड़ाई की स्थिति को दर्शाता है। यहाँ मेरे साथ भालू, यह बदसूरत है:

yourTeamState#theirTeamState

जहां XteamStateदिखता है:

name:activeSlot|member0state|member1state|member2state

activeSlotवर्तमान में कौन सा राक्षस सक्रिय है (0-2) दिखाता है। सदस्य राज्य दो स्वादों में आते हैं। यदि यह आपकी टीम है, तो यह अतिरिक्त जानकारी देती है। इसलिए,

आपका सदस्य:

name:id:attack:defense:speed:hp:typeid:poisonedturns:moveCount0:moveCount1:moveCount2:bonusAttack:bonusDefense:bonusSpeed:effectid:effectid:effectid

उनके सदस्य:

name:id:attack:defense:speed:hp:typeid:poisonedturns:effectid:effectid:effectid

idयदि आप उपयोग नहीं करना चाहते हैं तो बस एक पूर्णांक पहचानकर्ता का उपयोग कर सकते हैं name।

attack:defense:speedआपके आधार आँकड़े हैं।

poisonedturns आपको बताता है कि आपने कितने ज़हर लिए हैं।

moveCountXबताता है कि आपने प्रत्येक चाल के लिए कितने उपयोग छोड़े हैं। यदि 0, इसका उपयोग नहीं किया जा सकता है। असीमित चाल के लिए, यह नकारात्मक होगा।

bonus(stat) प्रत्येक अंक को आपके द्वारा निर्दिष्ट बोनस अंक की राशि है।

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

प्रभाव आईडी हैं:

0  NONE           (should not appear, internal use)
1  POISON
2  CONFUSION 
3  BURN 
4  SLEEP 
5  HEAL           (should not appear, internal use)
6  ATTACK_UP
7  ATTACK_DOWN
8  DEFENSE_UP
9  DEFENSE_DOWN
10 SPEED_DOWN

उत्तर:

memberSlot

केवल एक ही प्रतिक्रिया की आवश्यकता है एक एकल नंबर 0,1,2, यह बताना कि आप किस सदस्य को सक्रिय करना चाहते हैं। यह एक सदस्य होना चाहिए जो लड़ने में सक्षम हो। 1यदि सदस्य 1 मर चुका है तो वापस न भेजें ।

लड़ाई लड़ाई

प्रत्येक मोड़, आपको यह तय करने की आवश्यकता है कि क्या करना है।

प्रश्न:

A#battleState

battleStateयहाँ बिल्कुल के रूप में ऊपर वर्णित है।

उत्तर:

एक चाल का उपयोग करने के लिए, स्लॉट को वापस भेजें इस कदम में है। उदाहरण के लिए, यदि मैंने पंच को स्लॉट 0 को सौंपा है, तो पंच को भेजता 0है।

किसी अन्य सदस्य पर स्विच करने के लिए, सदस्य का स्लॉट प्लस दस भेजें । तो सदस्य 2 पर स्विच करने के लिए, भेजें 12।

कुछ भी नहीं [0,1,2,10,11,12] को अमान्य माना जाता है और इसके परिणामस्वरूप कोई भी कार्रवाई नहीं होगी।

बोनस आँकड़े

हर दो लड़ाइयों के बाद, आप प्रत्येक टीम के सदस्य के लिए एक गुप्त बोनस बिंदु प्राप्त करते हैं।

प्रश्न:

B#yourTeamState

आपकी टीम की स्थिति ऊपर बताई गई है, मुझे इसे दोहराएं नहीं।

उत्तर:

stat0:stat1:stat2

आपकी प्रतिक्रिया यह दर्शाएगी कि प्रत्येक टीम के सदस्य के लिए किस स्टेट को बढ़ाना है। हमला 0 है, डिफेंस 1 है, स्पीड 2 है।

तो सदस्य की गति बढ़ाने के लिए, सदस्य दो के हमले, और सदस्य के तीन बचाव के लिए, आप के साथ जवाब देंगे:

2:0:1

नियंत्रक

नियंत्रक को BitBucket: https: //[e-mail]/Geobits/codemon.git पर पाया जा सकता है

बस संकलित वर्ग फ़ाइलों, सबमिशन और खिलाड़ियों के सभी टॉस करें। एक फ़ोल्डर में चलाएँ और चलाएं।

नियंत्रक का मुख्य वर्ग कहा जाता है Tournament। उपयोग है:

java Tournament [LOG_LEVEL]

0-4 से लॉग स्तर बढ़ती जानकारी देते हैं। लेवल 0 टूर्नामेंट को चुपचाप चलाता है और सिर्फ नतीजे देता है, जहां लेवल 3 टर्न-बाय-टर्न कमेंट्री देता है। स्तर 4 डिबग आउटपुट है।

आप टूर्नामेंट में सबमिशन जोड़ सकते हैं players.confबस प्रोग्राम चलाने के लिए आवश्यक कमांड लाइन स्ट्रिंग जोड़ सकते हैं , प्रति पंक्ति। के साथ शुरू होने वाली लाइनें #टिप्पणियाँ हैं।

अपनी पोस्ट में, उस कमांड को शामिल करें जिसे मुझे अपने players.confऔर किसी भी संकलन के चरणों में जोड़ना होगा (यदि आवश्यक हो)।

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

विविध नियम

• आप किसी भी बाहरी संसाधन को नहीं पढ़ या लिख ​​सकते हैं (अपने स्वयं के सबफ़ोल्डर को छोड़कर, ऊपर उल्लिखित 32 kB तक)।

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

• अन्य प्रक्रियाओं / प्रस्तुतियाँ में हस्तक्षेप न करें। कोई उनका आह्वान नहीं करता, उनके डेटा को प्राप्त करने के लिए प्रतिबिंब का उपयोग करना, आदि। मेरे कंप्यूटर के साथ गड़बड़ न करें। बस कोशिश मत करो। यह मेरे विवेक पर है। भविष्य में प्रवेश करने वालों पर प्रतिबंध लगाया जा सकता है।

• प्रतियोगी अधिकतम दो प्रविष्टियों तक सीमित हैं । यदि आप अधिक जमा करते हैं, तो मैं केवल पहले जमा किए गए दो अंक प्राप्त करूंगा। यदि आप किसी को रद्द करना चाहते हैं, तो उसे हटा दें।

• प्रविष्टियाँ केवल अन्य प्रविष्टियों को प्रचलित करने के लिए मौजूद नहीं हो सकती हैं। इसके अलावा, आप अन्य प्रतियोगियों को अप्रत्यक्ष रूप से अयोग्य ठहराने की कोशिश नहीं कर सकते हैं (उदाहरण के लिए, DQ खिलाड़ियों के लिए 27M वर्ण टीम नाम का उपयोग करके जो इसे डिस्क में लिखने का प्रयास करते हैं)। प्रत्येक जमा को अपनी योग्यता के आधार पर जीतने के लिए खेलना चाहिए।

• आपका कार्यक्रम एक समय में अधिकतम एक बच्चे की प्रक्रिया को जन्म दे सकता है (कुल वंशज, प्रत्यक्ष नहीं)। आउटपुट देने के बाद दोनों मुख्य और किसी भी बच्चे की प्रक्रिया को सीधे समाप्त करना चाहिए। किसी भी तरह से, सुनिश्चित करें कि आप टाइमआउट पर नहीं जाते हैं।

• टूर्नामेंट मेरे कंप्यूटर पर उबंटू में आयोजित किया जाएगा जिसमें इंटेल i7 3770K प्रोसेसर होगा।

परिणाम

ये मौजूदा खिलाड़ियों के परिणाम हैं। यह शीर्ष दावेदारों के बीच बहुत करीब है, और मैं 500 तक के राउंड की संख्या को बढ़ाने के बारे में सोच रहा हूं (और मिलान करने के लिए बोनस अंक के अंतर को समायोजित करना)। कोई आपत्ति, टिप्पणी?

------- Final Results -------

158     Happy3Campers
157     LittleKid
71      InsideYourHead
68      HardenedTrio
46      BitterRivals

Google Play पर पूर्ण प्ले-बाय-प्ले परिणाम

Comments

मैं सबसे अच्छा होना चाहता हूं / जैसे कोई कोड कभी भी नहीं था / दुर्घटना न करने के लिए मेरा परीक्षण है / डिबग करने का मेरा कारण है! / मैं लैन / स्क्रिप्टिंग में दूर-दूर तक यात्रा करूंगा / समझने की कठिन कोशिश करूंगा / मेरा BIOS तले क्यों! / कोडेक्स, यह आप और मैं / सभी गोल्फ देख सकते हैं / कोडेक्स को देख सकते हैं, आप मेरे सबसे अच्छे दोस्त हैं / कार्यक्रम समाप्त होने के बाद! / कोडेमोन, एक लंग इतना सच / नहीं सेगफुल्स हमें के माध्यम से खींचेगा / आप मुझे सिखाएंगे और मैं आपको सिखाऊंगा / कोडीन, सभी को गोल्फ देगा!

— कज़ वोल्फ

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

— फोबोबर

@foobar मैं इससे बचना चाहता था क्योंकि यह लड़ाइयों को तराजू की n^2जगह लेता था n। सिर्फ वर्तमान 7 प्रतियोगियों और 100 राउंड के साथ, यह 2100 लड़ाई (बनाम 300 के रूप में, और 500 राउंड के साथ 1500) है। यह केवल बदतर हो जाता है क्योंकि अधिक प्रविष्टियाँ आती हैं। मैं राउंड के # को पीछे छोड़ सकता हूं, लेकिन मैं ऐसा करने में संकोच करता हूं कि अंतर्निहित परिवर्तनशीलता (स्टेटस एस्प के बारे में) के कारण, और 50 के कई (बोनस अंक के लिए) आसान है।

— भूतकाल

क्या इस चुनौती के लिए अपडेट की आवश्यकता नहीं है? :)

— घोलगोथ २१

@ GholGoth21 हाँ, मेरा मानना ​​है कि यह करता है। मैं शायद आज इसे प्राप्त नहीं कर सकता, लेकिन शायद कल या अगले दिन। यदि मुझे गुरुवार तक अपडेट नहीं करना है तो आप चैट में पिंग करें।

— जियोबिट्स

Answer 1

हैप्पी 3 कैंपर - PHP

कायरों का एक झुंड जो दुर्बल मंत्रों के साथ विपक्ष को शांत करना और उन्हें दूर देखना चाहता है।

संपादित करें : श्री Lumpy बुरी तरह से जकड़ा हुआ है और अब कोई बुरा शब्द नहीं कहेंगे

---

सुविधाजनकGrass - atk:50 def:99 spd:81 Confuse Poison Heal

एक जहरीला आर्मलेस बीवर जो समस्याग्रस्त हैंडशेक वाले लोगों को भ्रमित करना पसंद करता है

---

FlippyWater - atk:50 def:99 spd:81 Confuse Burn Heal

बोरिन-मी-मूर्खतापूर्ण वार्ता और लौ युद्धों के लिए एक नरम स्थान के साथ एक बुलेटिन बोर्ड के दिग्गज।

---

अखरोट के स्वाद काFire - atk:50 def:99 spd:81 Burn Poison Heal

सामूहिक विनाश के हथियार उसकी पसंदीदा कैंडीज हैं।

---

ढेलेदारPhp - lines:500 clarity:05 spd:01 Gather Guess Store

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

---

रणनीति

रणनीति में विरोधियों को जहर दिया, जलाया गया और जितनी जल्दी हो सके उलझन में है।
नींद का उपयोग नहीं किया गया था क्योंकि यह ऊपर के 3 मंत्रों की तुलना में कम शक्तिशाली लग रहा था।
भ्रम लंबे समय तक घातक है, क्योंकि यह 30% तक हमलों को कम करता है (दोनों क्षति से निपटने और स्पेल कास्टिंग), हीलर को खुद को ठीक करने से रोकता है और भारी हिटरों को बुरी तरह से नुकसान पहुँचाता है (50 डीएफ़ / 100 एटीके मॉन्स्टर खुद को नुकसान के 20 अंक देगा। )।

एक बार एक शत्रु को अच्छी तरह से चिपकाने के बाद, मेरे कैंपर बस उसे देखते हैं, सड़ाते हैं और खुद को मौत के घाट उतार देते हैं।

उच्च रक्षा और उपचार का उपयोग पीड़ा के दौरान आने वाली क्षति को कम करने के लिए किया जाता है।

जबकि मेरे 3 कैंपर लड़ रहे हैं, लुम्पी जादू हिरण दुश्मनों को हर चाल देखता है, और कभी-कभी उन्हें पहचानने में कामयाब होता है। जानकारी हमारे लड़ाकों को दी जाती है, जो इसका लाभ उठाने की पूरी कोशिश करते हैं।

रक्षा के बाद, गति को बढ़ावा देने के लिए सबसे महत्वपूर्ण स्टेट है।
अगला झटका आने से पहले उपचार को लागू करने के लिए पहल महत्वपूर्ण है।

हमले का उपयोग बिल्कुल नहीं किया जाता है।

क्या परम हथियार मंत्र हैं?

जहर, जलन और भ्रम जैसे मंत्र अन्य हमलों के समग्र रॉक / पेपर / कैंची तर्क से बच जाते हैं।

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

एक जहर और जले हुए राक्षस की जीवन प्रत्याशा 8 मोड़ से आगे नहीं जाती, यहां तक ​​कि 3 उपचार भी।

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

कोड

के साथ आह्वान किया php campers.php

यह एक बदसूरत गड़बड़ है, लेकिन स्पष्ट रूप से इंटरफ़ेस भी मदद नहीं करता है।

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

<?php

// ============================================================================
// Game
// ============================================================================
class G {
    static $code_type = array ("Normal", "Psychic", "Fire", "Water", "Grass", "?", "self"); 
    static $code_move = array    ("Punch", "Heal", "Slow", "Pain", "Sleep", "Weaken", "Fireball", "Burn", "Sharpen", "Watergun", "Confuse", "Shield", "Vine", "Poison", "Sap", "?", "self", "pass");
    static $move_uses = array (1000,3,5,1000,3,5,1000,3,5,1000,3,5,1000,3,5,   2000,2000);
    static $move_type      = array (0,0,0,1,1,1,2,2,2,3,3,3,4,4,4, 5,5,5);
    static $move_dmg       = array (20,0,10,20,0,10,20,0,10,20,0,10,20,0,10,  20,10,0);
    static $move_forbidden = array (1,1,1,0,0,0,4,4,4,2,2,2,3,3,3);
    static $code_effect = array ("N", "Poison", "Confuse", "Burn", "Sleep", "H", "Sharpen", "Weaken", "Shield", "Sap", "Slow"); 
    static $decode_type, $decode_move, $decode_effect;
    static $damage_multiplier = array (
        array (2, 0, 1, 1, 1, 0),
        array (0, 2, 1, 1, 1, 0),
        array (1, 1,.5, 2,.5, 0),
        array (1, 1,.5,.5, 2, 0),
        array (1, 1, 2,.5,.5, 0),
        array (2, 2, 2, 2, 2,-1),
        array (9, 9, 9, 9, 9, 9, 1));
    static $atk_score = array ("Poison"=> 1002, "Confuse"=>1001, "Burn"=>1000);
    static $status_field = "atk:def:spd:hp:type:Pturns";
    static $all_moves, $strong_moves, $medium_moves, $effect_moves, $possible_moves;

    function init()
    {
        self::$status_field = explode (":", self::$status_field);
        foreach (array ("type", "move", "effect") as $table) self::${"decode_$table"} = array_flip (self::${"code_$table"});
        foreach (self::$code_move as $c=>$m)
        {
            if ($m == "?") break;
            self::$all_moves[] = new Move($m);
            if (self::$move_uses[$c] >  5) self::$strong_moves[] = $m;
            if (self::$move_uses[$c] == 5) self::$medium_moves[] = $m;
            if (self::$move_uses[$c] == 3) self::$effect_moves[] = $m;
            for ($type = 0 ; $type != 5 ; $type++) if ((self::$move_uses[$c] >  5) && (self::$move_forbidden[$c] != $type)) self::$possible_moves[$type][] = $m;
        }
    }

    function __construct ($name, $team)
    {
        $this->turn = 0;
        $this->name = $name;
        $this->team = $team;
        $this->results_pending = false;
    }

    function parse_team ($tpack, $own_team)
    {
        $pack = explode ("|", $tpack);
        list ($name,$active) = explode (":", array_shift($pack));
        if ($own_team)
        {
            $team = $this->team;
        }
        else
        {
            if (!isset($this->enemies[$name])) $this->enemies[$name] = new Team(array (new Monster (), new Monster (), new Monster ()));
            $team = $this->foes = $this->enemies[$name];
        }
        $team->active = $active;
        foreach ($pack as $i=>$mpack) $team->monster[$i]->parse_monster ($own_team, $mpack);
    }

    function choose_active ()
    {
        // detect start of round
        $team = $this->team;
        $foes = $this->foes;
        foreach ($team->monster as $i=>$m) if ($m->hp > 0) $candidate[$i] = $m;
        if (count ($candidate) == 3)
        {
            $this->results_pending = false;
            $this->round++;

            // reinitialize all monsters
            foreach (array($team, $foes) as $t)
            foreach ($t->monster as $m)
                $m->start_round();

            // guess initial opponent
            $opponent = $foes->initial_opponent();
        }
        else
        {
            $this->analyze_last_round();
            $opponent = $foes->active();
        }
        return $this->do_switch ($opponent);
    }

    function choose_attacker ($foe)
    {
        foreach ($this->team->monster as $i=>$m) if ($m->can_attack($foe)) $candidate[$i] = $m;
        if (isset($candidate))
        {
            uasort ($candidate, function ($a,$b) use ($foe) { return ($a->atk_score != $b->atk_score) ? $b->atk_score - $a->atk_score : $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            return key($candidate);
        }
        return -1;
    }

    function do_switch ($foe)
    {
        $replacement = $this->choose_attacker ($foe);
        if ($replacement < 0)
        {
            $candidate =  $this->team->monster;
            uasort ($candidate, function ($a,$b) use ($foe) { return $b->life_expectancy($foe) - $a->life_expectancy($foe); });
            $replacement = key($candidate);
        }

        $this->old_own = $this->team->monster[$replacement];
        $this->old_own->attack = "pass";
        return $replacement;
    }

    function choose_action ()
    {
        $this->analyze_last_round();
        $own = $this->team->active();
        $foe = $this->foes->active();
        $this->old_own = $own;

        if ($own->hp <= $own->max_damage($foe) && $own->can_do ("Heal")) return $own->execute("Heal");
        if ($attack = $own->can_attack($foe)) return $own->execute($attack);
        if ($own->hp <= 50 && $own->can_do ("Heal")) return $own->execute("Heal");

        return 10 + $this->do_switch ($foe);    
    }

    function choose_bonus()
    {
        foreach ($this->team->monster as $m)
        {
            if ($m->spd_b == 0) { $m->spd_b++; $res[] = 2; }
            else                { $m->def_b++; $res[] = 1; }
        }
        return implode (":", $res);
    }

    function parse ($parts)
    {
        self::parse_team ($parts[1], true);
        self::parse_team ($parts[2], false);    
    }

    function analyze_last_round()
    {
        if ($this->results_pending)
        {
            $this->results_pending = false;

            $foes = $this->foes;
            $foe = null;
            foreach ($foes->monster as $m) if ($m->hp != $m->old->hp) $foe = $m;
            if ($foe === null) $foe = $foes->monster[$foes->active];

            $this->old_own->guess_attack($foe);
        }
    }

    function process ($line)
    {
        $parts = explode ("#", $line);
        switch ($parts[0])
        {
        case "T": // register for tournament
            echo "$this->name|$this->team";
            break;
        case "C": // designate active monster
            $this->parse ($parts);
            echo $this->choose_active();
            break;
        case "A": // choose round action
            $this->parse ($parts);
            echo $this->choose_action();

            // save current state
            foreach (array($this->team, $this->foes) as $t)
            foreach ($t->monster as $m)
            {
                unset ($m->old);
                $m->old = clone ($m);
            }
            $this->results_pending = true;
            break;
        case "B": // distribute stat bonus
            echo $this->choose_bonus();
            break;
        }

    }
}
G::init();

// ============================================================================
// Move
// ============================================================================
class Move {
    function __construct ($move)
    {
        $this->register($move);
    }

    function register ($move)
    {
        $this->type = G::$decode_move[$move];
        $this->reinit();
    }

    function reinit()
    {
        $this->uses = G::$move_uses[$this->type];
    }

    function __tostring() { return G::$code_move[$this->type]."($this->uses)"; }
}

// ============================================================================
// Monster
// ============================================================================
class Monster { 
    function __construct ($name="?", $type="?", $atk=100, $def=100, $spd=100, $m0="?", $m1="?", $m2="?")
    {
        $this->name = $name;
        $this->type = G::$decode_type[$type];
        $this->atk  = $atk;
        $this->def  = $def;
        $this->spd  = $spd;
        $this->hp   = 100;
        $this->move = array (new Move($m0), new Move($m1), new Move($m2));
        $this->atk_b = 0;
        $this->def_b = 0;
        $this->spd_b = 0;
        foreach (G::$code_effect as $e) $this->$e = 0;
    }

    function __tostring ()
    {
        return implode (":", array (
            $this->name,
            $this->type,
            $this->atk,
            $this->def,
            $this->spd,
            $this->move[0]->type,
            $this->move[1]->type,
            $this->move[2]->type));
    }

    function start_round()
    {
        foreach ($this->move as $m) $m->reinit();
    }

    function parse_monster ($own_team, $spack)
    {
        $pack = explode (":", $spack);
        $name = array_shift ($pack); // get name
        array_shift ($pack); // skip id
        if ($this->name == "?") $this->name = $name; // get paranoid
        else if ($this->name != $name) die ("expected $this->name, got $name");

        // store updated values
        foreach (G::$status_field as $var) $this->$var = array_shift ($pack);
        if ($own_team)
        {
            foreach ($this->move as $m) $m->new_count = array_shift($pack);
            $pack = array_slice ($pack, 3); // these are maintained internally
        }
        $var = array();
        foreach ($pack as $e) @$var[G::$code_effect[$e]]++; 
        foreach (G::$code_effect as $e) $this->$e = @$var[$e]+0;
    }

    function damage_recieved ($attack, $foe=null)
    {
        if ($attack == "self") $foe = $this;
        $a = G::$decode_move[$attack];
        $type = G::$move_type[$a];
        $dmg = g::$move_dmg[$a];

        if ($dmg == 0) return 0;

        $atk = ($foe ->atk+$foe ->atk_b) * pow (.8, ($foe ->Weaken - $foe ->Sharpen));
        $def = ($this->def+$this->def_b) * pow (.8, ($this->Sap    - $this->Shield ));

        $boost = ($foe->type == $type) ? 1.2 : 1;
        return max (floor ($dmg * $atk / $def * $boost * G::$damage_multiplier[$this->type][$type]), 1);
    }

    function guess_attack_from_effect ($attacks)
    {
        foreach ($attacks as $status) if ($this->$status != $this->old->$status) return $status;
        return "?";
    }

    function guess_attack_from_damage ($foe, $damages)
    {
        $select = array();
        foreach (G::$possible_moves[$foe->type] as $attack)
        {
            $dmg = $this->damage_recieved ($attack, $foe);
            foreach ($damages as $damage) if ($damage != 0 && abs ($dmg/$damage-1) < 0.1) $select[$attack] = 1;
        }
        $res = array();
        foreach ($select as $a=>$x) $res[] = $a;
        return $res;
    }

    function guess_attack ($foe)
    {
        $attempt = G::$decode_move[$this->old->attack];
        $success = ($this->old->attack == "pass");
        foreach ($this->move as $m)
        {
            if ($m->type == $attempt)
            {
                if ($m->new_count == $m->uses-1)
                {
                    $m->uses--;
                    $success = true;
                }
                break;
            }
        }

        $possible = array();
        $attack = $this->guess_attack_from_effect (array("Burn", "Confuse", "Poison", "Sleep", "Slow", "Weaken", "Sap"));
        if ($attack == "?") $attack = $foe->guess_attack_from_effect (array("Sharpen", "Shield"));
        if ($attack == "?")
        {
            $foe_damage = $this->old->hp - $this->hp - (10 * $this->Burn + 5 * $this->Pturns*$this->Poison);
            if ($this->old->attack == "Heal" && $success) $foe_damage += 50;
            $possible_dmg[] = $foe_damage;
            //;!;if ($this->Confuse) $possible_dmg[] = $foe_damage + $this->damage_recieved ("self");
            $possible = $this->guess_attack_from_damage ($foe, $possible_dmg);
            if (count ($possible) == 1) $attack = $possible[0];
        }
        if ($attack == "?")
        {
            $own_damage = $foe->old->hp - $foe->hp 
                        - (10 * $foe->Burn + 5 * $foe->Pturns*$foe->Poison)
                        + $foe->damage_recieved ($this->attack);
            if (abs ($own_damage/50+1) < 0.1) $attack = "Heal";
        }
        if ($attack != "?")
        {
            $type = G::$decode_move[$attack];
            if ($attack != "?")
            {
                foreach ($foe->move as $m) if ($m->type == $type) goto found_old;
                foreach ($foe->move as $m) if ($m->type == 15) { $m->register($attack); goto found_new; }
            }
            found_new:
            found_old:
        }
    }

    function max_damage($foe)
    {
        $dmg = 0;
        foreach ($foe->move as $m) $dmg = max ($dmg, $this->damage_recieved (G::$code_move[$m->type], $foe));
        return $dmg;
    }

    function expected_damage ($foe)
    {
        return $this->max_damage($foe) + 10 * $this->Burn + 5 * ($this->Pturns+1);
    }

    function life_expectancy ($foe)
    {
        $hp = $this->hp;
        $poison = $this->Pturns;
        $heal = $this->can_do ("Heal");
        $dmg = $this->max_damage($foe);
        for ($turn = 0 ; $hp > 0 && $turn < 10; $turn++)
        {
            $hp -= 10 * $this->Burn + 5 * $poison;
            if ($poison > 0) $poison++;
            $hp -= $dmg;
            if ($hp <= 0 && $heal > 0) { $hp+=50; $heal--; }
        }
        return 100 * $turn + $this->hp;
    }

    function can_attack ($foe)
    {
        $attack = false;
        if ($this->hp > 0)
        {
            if      (!$foe->Poison  && $this->can_do ("Poison" )) $attack = "Poison";
            else if (!$foe->Confuse && $this->can_do ("Confuse")) $attack = "Confuse";
            else if (!$foe->Burn    && $this->can_do ("Burn"   )) $attack = "Burn";
        }
        $this->atk_score = ($attack === false) ? 0 : G::$atk_score[$attack];
        return $attack;
    }

    function can_do($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $m) if ($m->type == $type && $m->uses > 0) return $m->uses;
        return false;
    }

    function execute($move)
    {
        $type = G::$decode_move[$move];
        foreach ($this->move as $i=>$m) if ($m->type == $type) 
        { 
            if ($m->uses > 0)
            {
//;!;               $m->uses--;
                $this->attack = $move;
            }
            else $this->attack = "pass";
            return $i; 
        }
        die ("$this asked to perform $move, available ".implode(",", $this->move));
    }
}

// ============================================================================
// Team
// ============================================================================
class Team {
    function __construct ($members)
    {
        $this->monster = $members;
    }

    function __tostring()
    {
        return implode ("|", $this->monster);
    }

    function active ()
    {
        return $this->monster[$this->active];
    }

    function initial_opponent()
    {
        return $this->monster[0];
    }
}

// ============================================================================
// main
// ============================================================================
$input = $argv[1];

$team_name = "H3C";
$mem_file = "$team_name/memory.txt";
$trc_file = "$team_name/trace.txt";
if (!file_exists($team_name)) mkdir($team_name, 0777, true) or die ("could not create storage directory '$team_name'");
if ($input == "T") array_map('unlink', glob("$team_name/*.txt"));

if (file_exists($mem_file)) $game = unserialize (file_get_contents ($mem_file));
else
{
    $team = new Team (
        array (
            new Monster ("Handy" , "Grass" , 50, 99, 81, "Confuse", "Poison", "Heal"),
            new Monster ("Nutty" , "Fire"  , 50, 99, 81, "Burn"   , "Poison", "Heal"),
            new Monster ("Flippy", "Water" , 50, 99, 81, "Confuse" , "Burn" , "Heal")));
    $game = new G($team_name,$team);
}

$game->process ($input);
file_put_contents ($mem_file, serialize($game));

परिणाम

लिटिलकिड अभी भी menacing है, लेकिन मेरी तिकड़ी ने अपने विषैले शैतानों को उचित अंतर से हराया।

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

ग्रह जावास्क्रिप्ट के नए दावेदार एक-एक में टीम के साथ बराबरी पर हैं, लेकिन वे अन्य प्रतियोगियों के मुकाबले बदतर हैं। वे वास्तव में लिटिलकिड के स्कोर को कम करने में मदद करते हैं :)।

तो ऐसा लगता है कि मेरे cuddly दोस्त पहाड़ी के राजा बने हुए हैं - अभी के लिए ...

170             H3C
158             Nodemon
145             LittleKid
55              InsideYourHead
42              HardenedTrio
30              BitterRivals

Comments

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

— Sp3000

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

मैं इसकी तुलना कैंची, कागज, चट्टान जैसे गैर-सकर्मक खेल से कर सकता हूँ - क्योंकि प्रभावों में थोड़ा समय लगता है, एक पूर्ण-आक्रमण टीम आपको नीचे ले जाने में सक्षम होना चाहिए :)

— Sp3000

हां, यह वही है जिसकी मैंने कल्पना की थी जैसे ही मुझे जहर और जला के लिए कोई उपाय नहीं दिखाई दिया। मेरे सपने को जीवंत करने के लिए धन्यवाद।

— विगत

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

Answer 2

हार्डिनट्रिओ, पायथन 3

चूंकि जियोबिट्स हमें दो सबमिशन देने के लिए काफी अच्छा था , मैंने सोचा कि मैं पहले एक के लिए मूर्खतापूर्ण कुछ प्रस्तुत करूंगा: पी

पार्टी एक ही आँकड़े और चाल के साथ तीन कोडनेम (मेटापॉड 1, मेटापॉड 2, मेटापॉड 3) है:

• 80 हमले, 100 रक्षा, 50 गति
• पंच, हील, शील्ड हार्डन

सभी बोनस अंक भी रक्षा को दिए गए हैं।

---

from collections import namedtuple
import sys

BattleState = namedtuple("BattleState", ["us", "them"])
TeamState = namedtuple("TeamState", ["name", "active", "members"])
MemberState = namedtuple("MemberState", ["name", "id", "attack", "defense", "speed", "hp",
                                         "typeid", "poisonedturns", "otherstats"])

def parse_battle_state(state):
    return BattleState(*map(parse_team_state, state.split("#")))

def parse_team_state(state):
    na, *members = state.split("|")
    name, active = na.split(":")
    return TeamState(name, int(active), list(map(parse_member_state, members)))

def parse_member_state(state):
    name, id_, attack, defense, speed, hp, typeid, poisonedturns, *rest = state.split(":")
    return MemberState(name, int(id_), float(attack), float(defense), float(speed),
                       float(hp), int(typeid), int(poisonedturns), rest)

command = sys.argv[1].strip()

if command.startswith("T"):
    print("HardenedTrio|Metapod1:0:80:100:50:0:1:11|"
          "Metapod2:0:80:100:50:0:1:11|Metapod3:0:80:100:50:0:1:11")

elif command.startswith("C"):
    battle_state = parse_battle_state(command[2:])

    for i, codemon in enumerate(battle_state.us.members):
        if codemon.hp > 0:
            print(i)
            break

elif command.startswith("A"):
    battle_state = parse_battle_state(command[2:])
    current_codemon = battle_state.us.members[battle_state.us.active]

    if current_codemon.hp < 50 and int(current_codemon.otherstats[1]) > 0:
        print(1) # Heal up if low

    elif int(current_codemon.otherstats[2]) > 0:
        print(2) # Harden!

    else:
        print(0) # Punch!

elif command.startswith("B"):
    print("1:1:1")

साथ दौड़ो

py -3 <filename>

(या आपकी स्थापना के आधार पर python/ python3इसके बजाय py)

Comments

जो आपको नहीं मारता, वह आपको कठोर बनाता है।

— FryAmTheEggman

@FryAmTheEggman मेटापॉड, हार्डन!

— Sp3000

मैं आपके कोड को पढ़ने की कोशिश कर रहा हूं, लेकिन मैं उलझन में हूं int(current_codemon.otherstats[1])>0। यह सच है अगर वह एक स्थिति प्रभाव है? और वह केवल कठोर का उपयोग करता है यदि उसके दो स्थिति प्रभाव हैं?

— मूविंग डक

@MooDDuck आपके कोडनाम के लिए आपको moveCounts से पहले मिला है effectid, इसलिए यह जाँच रहा है कि क्या यह अभी भी हार्डन का उपयोग कर सकता है। मैं पार्स करने के साथ आलसी हो गया, यही वजह है कि यह वहां से टकरा गया।

— Sp3000

@ Sp3000: ओह! सही! HAHAHA!

— डक डक

Answer 3

अपने सिर के अंदर, रूबी

• ब्रायन : साइकिक, अटैक: १००, रक्षा: ५०, गति: ,०, दर्द, आग का गोला, वाटरगन
• एलिमोन 1 : साइकिक, अटैक: 100, डिफेन्स: 50, स्पीड: 80, फायरबॉल, वाटरगुन, वाइन
• एलिमोन 2 : साइकिक, अटैक: 100, डिफेंस: 50, स्पीड: 80, फायरबॉल, वॉटरगन, वाइन

TEAM_SPEC = "InsideYourHead"+
            "|Brian:1:100:50:80:3:6:9"+
            "|Elemon1:1:100:50:80:6:9:12"+
            "|Elemon2:1:100:50:80:6:9:12"

def parse_battle_state request
    request.map do |team_state|
        state = {}
        parts = team_state.split '|'
        state[:active] = parts.shift.split(':')[1].to_i
        state[:monsters] = parts.map do |monster_state|
            monster = {}
            parts = monster_state.split(':')
            monster[:name] = parts[0]
            monster[:hp] = parts[5].to_i
            monster[:type] = parts[6].to_i
            monster
        end
        state
    end
end

request = ARGV[0].split '#'
case request.shift
when 'T'
    puts TEAM_SPEC
when 'C'
    battle_state = parse_battle_state request
    my_state = battle_state[0]
    puts my_state[:monsters].find_index {|monster| monster[:hp] > 0}
when 'A'
    battle_state = parse_battle_state request
    my_state, their_state = *battle_state
    my_monster = my_state[:monsters][my_state[:active]]
    their_monster = their_state[:monsters][their_state[:active]]
    puts [1,0,1,2,0][their_monster[:type]]
when 'B'
    puts '0:0:0'
end

साथ दौड़ो

ruby InsideYourHead.rb

यह मनु के बॉट के खिलाफ बहुत अच्छी तरह से काम नहीं करता है, लेकिन यह अन्य तीन को हरा देता है। टीम और राक्षस नाम बहुत यादृच्छिक हैं ... अगर मैं कुछ बेहतर करूं तो मैं उन्हें बदल सकता हूं

रणनीति बहुत सरल है: हमला! सभी तीन राक्षसों में केवल शुद्ध हमले की चाल है, और वे प्रतिद्वंद्वी के राक्षस के प्रकार के आधार पर अपनी चाल चुनते हैं।

मैं बाद में चंगा करने के साथ प्रयोग कर सकता हूं।

Comments

यह और अधिक दिलचस्प हो जाता है। मुझे पता था कि मैं आपके लिए उस पर, मार्टिन :)

Answer 4

लिटिलकिड, जावा

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

public class LittleKid {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("Geobits says you can't do this.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "LittleKid";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                out += "|Poisoner:0:80:100:50:0:1:13";
                break;
            case "B":
                out = "1:1:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];
                int pick = 0;

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = String.valueOf(pick);
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int enemyActive = getActive(them);
                if (getField(me, HP, active) < 50 && getField(me, MOVE1, active) != 0) {
                    out = "1";
                } else if (getEffectCount(them, POISON, enemyActive, false) < 1 && getField(me, MOVE2, active) != 0) {
                    out = "2";
                } else {
                    out = "0";
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6;
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10;

    final static int POISON =           1;
}

Comments

" जियोबिट्स का कहना है कि आप ऐसा नहीं कर सकते हैं ": डी

— जियोबिट्स

लगता है जहर इस खेल में असली A- बम है :)

Answer 5

नोडमोन - जावास्क्रिप्ट

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

मेरे पास PHP स्थापित नहीं है इसलिए यह कैंपरों के खिलाफ परीक्षण नहीं किया गया है, लेकिन यह मेरे परीक्षणों में लिटिलकिड के लिए एक सभ्य प्रतियोगी प्रतीत होता है (और कड़वे प्रतिद्वंद्वियों को समाप्त करता है)।

/*jshint node:true*/
'use strict';

var fs = require('fs');

var dataFile = 'Nodemon/data.json';
function getData(callback) {
  fs.readFile(dataFile, 'utf8', function(err, contents) {
    var data = {round: 0};

    if(!err) {
      data = JSON.parse(contents);
    }

    callback(data);
  });
}

function saveData(data, callback) {
  fs.mkdir('Nodemon', function() {    
    fs.writeFile(dataFile, JSON.stringify(data), callback);
  });
}

var effect = {
  poison: '1',
  confusion: '2',
  burn: '3',
  sleep: '4',
  heal: '5',
  attackUp: '6',
  attackDown: '7',
  defenseUp: '8',
  defenseDown: '9',
  speedDown: '10'
};

function parseMemberCommon(args) {
  return {
    name: args[0],
    id: args[1],
    baseAttack: +args[2],
    baseDefense: +args[3],
    baseSpeed: +args[4],
    hp: +args[5],
    typeId: args[6],
    poisonedTurns: +args[7],
    effects: args.slice(8)
  };
}

function parseOwnMember(arg) {
  var args = arg.split(':');

  var ownArgs = args.splice(8, 6);

  var member = parseMemberCommon(args);

  member.moveCount = [
    +ownArgs[0],
    +ownArgs[1],
    +ownArgs[2]
  ];

  member.bonusAttack = +ownArgs[3];
  member.bonusDefense = +ownArgs[3];
  member.bonusSpeed = +ownArgs[3];

  return member;
}

function parseOpponentMember(arg) {
  return parseMemberCommon(arg.split(':'));
}

function parseTeamStateCommon(arg, memberParse) {
  var args = arg.split(':');
  var state = {
    name: args[0],
    members: []
  };
  args = arg.substring(state.name.length + 1).split('|');
  var activeSlot = args[0];
  for(var index = 1; index < args.length; index++) {
    state.members.push(memberParse(args[index]));
  }
  state.activeMember = state.members[activeSlot];
  return state;
}

function parseOwnState(arg) {
  return parseTeamStateCommon(arg, parseOwnMember);
}

function parseOpponentState(arg) {
  return parseTeamStateCommon(arg, parseOpponentMember);
}

function parseBattleState(arg) {
  var args = arg.split('#');
  return {
    own: parseOwnState(args[0]),
    opponent: parseOpponentState(args[1])
  };
}

function teamData() {

  saveData({round:0}, function() {
    console.log('Nodemon|' + 
      'Charasaur:0:50:80:100:10:13:1|' +
      'Bulbtortle:4:50:80:100:10:13:1|' +
      'Squirtmander:1:50:80:100:10:13:4');
  });
}

function getActiveIndex(battleState) {
  for(var index = 0; index < battleState.own.members.length; index++) {
    var member = battleState.own.members[index];
    if(member.hp > 0) {
      return index;
    }
  }
}

function chooseActive(arg) {
  var battleState = parseBattleState(arg);

  getData(function(data) {
    var allFull = true;
    for(var index = 0; index < battleState.opponent.members.length; index++) {
      var member = battleState.opponent.members[index];
      if(!data.maxSpeed || member.baseSpeed > data.maxSpeed) {
        data.maxSpeed = member.baseSpeed;
      }
      if(member.hp < 100) {
        allFull = false;
      }
    }

    if(allFull) {
      data.round++;
    }

    saveData(data, function() {
      console.log(getActiveIndex(battleState));
    });    
  });
}

function useMove(moves, battleState) {
  var fighter = battleState.own.activeMember;

  for(var moveIndex = 0; moveIndex < moves.length; moveIndex++) {
    var move = moves[moveIndex];
    if(fighter.moveCount[move]) {
      return move;
    }

    for(var memberIndex = 0; memberIndex < battleState.own.members.length; memberIndex++) {
      var member = battleState.own.members[memberIndex];

      if(member.hp > 0 && member.moveCount[move] > 0) {
        return 10 + memberIndex;
      }
    }
  }

  return -1;  //do nothing
}

function battleAction(arg) {
  var battleState = parseBattleState(arg);

  var fighter = battleState.own.activeMember;
  var opponent = battleState.opponent.activeMember;

  var attemptedMoves = [];

  if(opponent.effects.indexOf(effect.poison) === -1) {
    attemptedMoves.push(1);
  }

  if(opponent.effects.indexOf(effect.confusion) === -1) {
    attemptedMoves.push(0);
  }

  if(fighter.name === 'Squirtmander') {
    //sleep
    if(opponent.effects.indexOf(effect.sleep) === -1) {
      attemptedMoves.push(2);
    }
  }
  else {
    //heal
    if(fighter.hp <= 60) {
      attemptedMoves.push(2);
    }
  }

  console.log(useMove(attemptedMoves, battleState));
}

function bonusStats(arg) {
  var teamState = parseOwnState(arg);

  getData(function(data) {
    var result = '1:';

    if(data.round % 4 === 0) {
      result += '1:';
    }
    else {
      result += '2:';
    }
    if(teamState.members[2].baseSpeed + teamState.members[2].bonusSpeed > data.maxSpeed + (data.round / 2)) {
      result += '1';
    }
    else {
      result += '2';
    }
    console.log(result);
  });
}

var actions = {
  'T': teamData,
  'C': chooseActive,
  'A': battleAction,
  'B': bonusStats
};

var arg = process.argv[2];
actions[arg[0]](arg.substring(2));

साथ दौड़ो

node nodemon

पुनश्च उदासीनता के लिए क्षमा याचना ।

Comments

यह एक सर्वर-साइड स्क्रिप्ट वैश्विक युद्ध के लिए बढ़ रहा है: D

Answer 6

कड़वा प्रतिद्वंद्वी - जावा

एक ग्रास / फायर / वाटर टीम जो इसे स्विच करना पसंद करती है।

Greenosaur

किसी पर कम से कम तटस्थ कवरेज है। रक्षा की कमी के लिए उच्च गति।

Type: Grass
Attack:   80     Vine
Defense:  50     Punch
Speed:   100     Pain

Searizard

कम हमले के साथ सैप दुश्मनों को देता है। उसके बाद बर्न्स और फायरबॉल।

Type: Fire
Attack:  100     Fireball
Defense:  50     Burn
Speed:    80     Sap

विष्फोटक चिन्ह

अपनी पहले से ही उच्च रक्षा को बढ़ाने के लिए शील्ड का उपयोग करता है। आवश्यक होने पर चंगा करता है।

Type: Water
Attack:   80     Watergun
Defense: 100     Shield
Speed:    50     Heal

कोड

यह नियंत्रक के साथ भी शामिल है। यह है एक प्रतिस्पर्धी टीम, DummyTeam के विपरीत है। इसके लिए आवश्यक कमांड players.confहै:

java BitterRivals

---

public class BitterRivals {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You're not doing this right. Read the spec and try again.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String me, them, out = "";
        switch(sections[0]){
            case "T":
                out = "BitterRivals";
                out += "|Greenosaur:4:80:50:100:12:0:3";
                out += "|Searizard:2:100:50:80:6:7:14";
                out += "|Blastshield:3:80:100:50:9:11:1";
                break;
            case "B":
                out = "2:0:1";
                break;
            case "C":
                me = sections[1];
                them = sections[2];

                int pick = 0;
                switch(getField(them, TYPE, getActive(them))){
                    case 0:
                    case 1:
                    case 3:
                        pick = 0;
                        break;
                    case 2:
                        pick = 2;
                        break;
                    case 4:
                        pick = 1;
                        break;
                }

                if(!isAlive(me, pick)){
                    for(int i=0;i<3;i++){
                        if(isAlive(me,i))
                            pick = i;
                    }
                }

                out = pick + "";
                break;
            case "A":
                me = sections[1];
                them = sections[2];
                int active = getActive(me);
                int oType = getField(them, TYPE, getActive(them));
                switch(active){
                    case 0:         // Greenosaur
                        switch(oType){
                            case 0:
                            case 4:
                                out = "1";
                                break;
                            case 1:
                                out = "2";
                                break;
                            case 3:
                                out = "0";
                                break;
                            case 2:
                                if(isAlive(me, 2)){
                                    out = "12";
                                } else if(isAlive(me, 1)){
                                    out = "11";
                                } else {
                                    out = "1";
                                }
                                break;
                        }
                        break;
                    case 1:         // Searizard
                        if(oType == 3){
                            if(isAlive(me, 0)){
                                out = "10";
                                break;
                            } else if(isAlive(me, 2)){
                                out = "12";
                                break;
                            }
                            if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                out = "1";
                            } else if(getField(me, MOVE2, active) > 0){
                                out = "2";
                            } else {
                                out = "3";
                            }                           
                        } else {
                            if(getField(them, ATTACK, getActive(them)) < 80){
                                if(getEffectCount(them, DEFENSE_DOWN, getActive(them), false) < 1 && getField(me, MOVE2, active) > 0){
                                    out = "2";
                                    break;
                                } else if(getEffectCount(them, BURN, getActive(them), false) < 1 && getField(me, MOVE1, active) > 0){
                                    out = "1";
                                    break;
                                }
                            }
                            out = "0";
                        }
                        break;
                    case 2:         // Blastshield
                        if(oType == 4){
                            if(isAlive(me, 1)){
                                out = "11";
                                break;
                            } else if(isAlive(me, 0)){
                                out = "10";
                                break;
                            }
                        }
                        if(getField(me, HP, active) < 50 && getField(me, MOVE2, active) > 0){
                            out = "2";
                        } else if(getEffectCount(me, DEFENSE_UP, active, true) < 3 && getField(me, MOVE1, active) > 0){
                            out = "1";
                        } else {
                            out = "0";
                        }
                        break;
                }
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }

    static boolean isAlive(String teamState, int who){
        return getField(teamState, HP, who) > 0;
    }

    static int getActive(String teamState){
        return Integer.parseInt(teamState.split("\\|")[0].split(":")[1]);
    }

    static int getField(String teamState, int field, int who){
        String[] fields = teamState.split("\\|")[who+1].split(":");
        return Integer.parseInt(fields[field]);
    }

    static int getEffectCount(String teamState, int effect, int who, boolean mine){
            String[] fields = teamState.split("\\|")[who+1].split(":");
            int count = 0;
            for(int i=mine?14:8;i<fields.length;i++){
                if(Integer.parseInt(fields[i]) == effect)
                    count++;
            }
            return count;
    }

    final static int ID =       1; 
    final static int ATTACK =   2; 
    final static int DEFENSE =  3; 
    final static int SPEED =    4; 
    final static int HP =       5; 
    final static int TYPE =     6; 
    final static int PTURNS =   7; 
    final static int MOVE0 =    8; 
    final static int MOVE1 =    9; 
    final static int MOVE2 =    10; 
    final static int HA =       11; 
    final static int HD =       12; 
    final static int HS =       13; 

    final static int POISON =           1;
    final static int CONFUSION =        2;
    final static int BURN =             3;
    final static int SLEEP =            4;
    final static int ATTACK_UP =        6;
    final static int ATTACK_DOWN =      7;
    final static int DEFENSE_UP =       8;
    final static int DEFENSE_DOWN =     9;
    final static int SPEED_DOWN =       10;
}

Answer 7

त्रुटि 310: बहुत सारे रीडायरेक्ट - C ++

जहर के कहर का मुकाबला करने के लिए एक उच्च प्रशिक्षित और संगठित टीम

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

---

विषहर औषध

Type : Normal - atk:50 def:100 spd:80 - Poison/Burn/Heal

मारक को जहर पसंद है। इतना कि मैं उसे जहर के हमलों से भागने से रोक नहीं सकता।

---

जेन

Type : Fire - atk:100 def:80 spd:50 - Poison/Vine/Heal

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

---

Triforce

Type : Psychic - atk:88 def:60 spd:82 - Fireball/Watergun/Vine

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

---

आप यहां टीम डाउनलोड कर सकते हैं:

लिनक्स:

http://dl.free.fr/iHYlmTOQ2

के साथ लॉन्च ./Error310TMR

खिड़कियाँ :

http://dl.free.fr/vCyjtqo2s

के साथ लॉन्च ./Error310TMR.exe

कोड एक पूर्ण c ++ प्रोजेक्ट है। मुझे नहीं पता कि इसे कैसे प्रकाशित किया जाए।

$ wc -l src/*
    165 src/BruteForce.cpp
     26 src/BruteForce.h
    349 src/Codemon.cpp
     77 src/Codemon.h
     21 src/Logger.cpp
     35 src/Logger.h
    105 src/NoTimeToExplain.cpp
     27 src/NoTimeToExplain.h
    240 src/Recoverator.cpp
     31 src/Recoverator.h
     26 src/StrManip.cpp
     16 src/StrManip.h
    303 src/Team.cpp
     68 src/Team.h
     88 src/TooManyRedirects.cpp
     24 src/TooManyRedirects.h
     87 src/Unrecoverable.cpp
     27 src/Unrecoverable.h
     59 src/enums.cpp
    119 src/enums.h
     68 src/main.cpp
   1961 total

लेकिन यह बहुत प्रभावी है:

------- Final Results -------

176     Error310TMR
131     H3C
130     LittleKid
121     Nodemon
58      InsideYourHead
47      HardenedTrio
37      BitterRivals

Answer 8

परियों की कहानी

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

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

#!/bin/perl
use 5.20.0;
use strict;

use constant MINE => 0;
use constant THEIRS => 1;

$_ = $ARGV[0];

if(/^T/){
    say 'FairyTale|Fairy:1:89:90:51:3:4:13|Dragon:2:100:50:80:6:1:8|Assassin:0:70:60:100:0:1:10';

} elsif(/^C#(.*)/){
    my $state = readBattleState($1);
    if($state->[MINE]->{$state->[MINE]->{slot}}{hp}){
        say $state->[MINE]->{slot};
    } elsif($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp}){
        say (($state->[MINE]->{slot}+1)%3);
    } else {
        say (($state->[MINE]->{slot}+2)%3);
    }

} elsif(/^A#(.*)/){
    my $state = readBattleState($1);
    my @actives = (
        $state->[MINE]->{$state->[MINE]->{slot}},
        $state->[THEIRS]->{$state->[THEIRS]->{slot}}
    );
    if($state->[MINE]->{slot} == 0){
        if(!exists($actives[THEIRS]{effects}{4}) && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif(!exists($actives[THEIRS]{effects}{1}) && $actives[MINE]{pp}->[2]) {
            say 2;
        } elsif(!$actives[THEIRS]{type}) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 1){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } else {
            say 0;
        }
    } elsif($state->[MINE]->{slot} == 2){
        if(!exists($actives[MINE]{effects}{6}) && $actives[MINE]{pp}->[2]){
            say 2;
        } elsif ($actives[MINE]{hp} > 10 && $actives[MINE]{hp} < 50 && $actives[MINE]{pp}->[1]){
            say 1;
        } elsif($actives[THEIRS]{type} == 1) {
            if($state->[MINE]->{($state->[MINE]->{slot}+1)%3}{hp} > 0){
                say (($state->[MINE]->{slot}+1)%3);
            } elsif($state->[MINE]->{($state->[MINE]->{slot}+2)%3}{hp} > 0) {
                say (($state->[MINE]->{slot}+2)%3);
            } else {
                say 0;
            }
        } else {
            say 0;
        }
    }

} elsif(/^B#(.*)/){
    my $state = readTeam($1, 1);
    say '1:0:2';
}

sub readBattleState {
    local $_ = $_[0];
    if(/^(.*?)#(.*?)$/){
        my @teams;
        $teams[0] = readTeam($1, 1);
        $teams[1] = readTeam($2, 0);
        return \@teams;
    }
}

sub readTeam {
    my $isMine = $_[1];
    local $_ = $_[0];
    if(/.*?:(?<slot>.*?)\|(.*?)\|(.*?)\|(.*?)$/){
        my %team;
        $team{slot} = $1;
        $team{0} = $isMine ? readYourMember($2) : readTheirMember($2);
        $team{1} = $isMine ? readYourMember($3) : readTheirMember($3);
        $team{2} = $isMine ? readYourMember($4) : readTheirMember($4);
        return \%team;
    }
    return 0;
}

sub readYourMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?):(?<move0>.*?):(?<move1>.*?):(?<move2>.*?):(?<batk>.*?):(?<bdef>.*?):(?<bspd>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk}+$+{batk},
            def    => $+{def}+$+{bdef},
            spd    => $+{spd}+$+{bspd},
            type   => $+{type},
            pp     => [$+{move0}, $+{move1}, $+{move2}],
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
}

sub readTheirMember {
    local $_ = $_[0];
    if(/(?<name>.*?):(?<id>.*?):(?<atk>.*?):(?<def>.*?):(?<spd>.*?):(?<hp>.*?):(?<type>.*?):(?<poison>.*?)(?<effects>(?::.*)|$)/){
        my %effects = map { $_ => 1 } readEffects($+{effects});
        my %member = (
            name   => $+{name},
            id     => $+{id},
            hp     => $+{hp},
            atk    => $+{atk},
            def    => $+{def},
            spd    => $+{spd},
            type   => $+{type},
            poistrn=> $+{poison},
            effects=> \%effects
        );
        return \%member;
    }
    return 0;
}

sub readEffects {
    local $_ = $_[0];
    my @retval = /:([^:]*)/g;
    if(!@retval){
        @retval = (0);
    }
    return @retval;
}

साथ दौड़ो

perl fairytale.pl

Comments

यह बॉट पहले मर जाने के बाद मृत सदस्यों को 'सक्रिय' चुनने की कोशिश के लिए बाहर निकालता है। यह कभी भी पहली लड़ाई से आगे नहीं बढ़ पाता है जिसे मैं देख सकता हूं।

— भूतकाल

वास्तव में? मैंने सोचा था कि मैं उस बग से पहले काम कर चुका हूं, शायद यह उस कोड का एक पुराना संस्करण है ...

— mezzoEmrys

न भूलें कि जब एक कोडनेम को खटखटाया जाता है, तो उसके उपचार के समय 0 या उससे कम हो जाता है । तो if($state->[MINE]->{$state->[MINE]->{slot}}{hp})बयान बिना सही ढंग से काम नहीं करेगा >0।

— घोलगोथ 21

आह, हाँ, यह करना होगा।

— मेज़ोइमरोज़

Answer 9

डमी टीम - जावा

(गैर-प्रतिस्पर्धात्मक सीडब्ल्यू)

यह अभ्यास करने के लिए एक डमी टीम है। यह सभी सामान्य प्रकार हैं, जो अपनी चाल (पंच, हील, स्लो) को प्रत्येक मोड़ के बीच बेतरतीब ढंग से चुनते हैं। इसके साथ मजे करो।

public class DummyTeam {

    public static void main(String[] args) {
        if(args.length < 1){
            System.out.println("You need to run this from the tournament. Try to keep up.");
            System.exit(0);
        }

        String[] sections = args[0].split("#");
        String out = "";
        switch(sections[0]){
            // team data
            //      sends back all Normal types with minimum stats and Normal moves (randomized name suffixes to distinguish in tests)
            case "T":
                out = "DummyTeam";
                for(int i=0;i<3;i++)
                    out += "|Dummy"+((char)(Math.random()*26)+65) + i + ":0:50:50:50:0:1:2";
                break;
            // bonus points
            //      shoves them all in defense every time
            case "B":
                out = "1:1:1";
                break;
            // choose active
            //      picks last active if alive, otherwise loops to find first living member
            case "C":
                String[] team = sections[1].split("\\|");
                int current = Integer.parseInt(team[0].split(":")[1]);
                if(Integer.parseInt(team[current+1].split(":")[5]) > 0){
                    out = current + "";
                } else {
                    for(int i=1;i<team.length;i++){
                        if(Integer.parseInt(team[i].split(":")[5]) > 0){
                            out = (i - 1) + "";
                        }
                    }
                }               
                break;
            // choose action
            //      chooses a random move. does not check if it ran out of uses, so wastes turns quite often
            case "A":
                out = ((int)(Math.random()*3)) + "";
                break;
            default:
                out = "Invalid query from controller.";             
        }
        System.out.println(out);
    }


}