द रॉक, पेपर, कैंची, छिपकली, स्पिक टूर्नामेंट ऑफ एपिकनेस

Question

सबसे हाल का लीडरबोर्ड @ 2014-08-02 12:00

| Pos # | Author               | Name                    | Language   | Score | Win   | Draw  | Loss  | Avg. Dec. Time |
+-------+----------------------+-------------------------+------------+-------+-------+-------+-------+----------------+
| 1st   | Emil                 | Pony                    | Python2    | 064   | 064   | 000   | 005   | 0026.87 ms     |
| 2nd   | Roy van Rijn         | Gazzr                   | Java       | 062   | 062   | 001   | 006   | 0067.30 ms     |
| 2nd   | Emil                 | Dienstag                | Python2    | 062   | 062   | 001   | 006   | 0022.19 ms     |
| 4th   | ovenror              | TobiasFuenke            | Python2    | 061   | 061   | 001   | 007   | 0026.89 ms     |
| 5th   | PhiNotPi             | BayesianBot             | Perl       | 060   | 060   | 000   | 009   | 0009.27 ms     |
| 6th   | Claudiu              | SuperMarkov             | Python2    | 058   | 058   | 001   | 010   | 0026.77 ms     |
| 7th   | histocrat            | Alternator              | Ruby       | 057   | 057   | 001   | 011   | 0038.53 ms     |
| 8th   | histocrat            | LeonardShelby           | Ruby       | 053   | 053   | 000   | 016   | 0038.55 ms     |
| 9th   | Stretch Maniac       | SmarterBot              | Java       | 051   | 051   | 002   | 016   | 0070.02 ms     |
| 9th   | Martin Büttner       | Markov                  | Ruby       | 051   | 051   | 003   | 015   | 0038.45 ms     |
| 11th  | histocrat            | BartBot                 | Ruby       | 049   | 049   | 001   | 019   | 0038.54 ms     |
| 11th  | kaine                | ExcitingishBot          | Java       | 049   | 049   | 001   | 019   | 0065.87 ms     |
| 13th  | Thaylon              | UniformBot              | Ruby       | 047   | 047   | 001   | 021   | 0038.61 ms     |
| 14th  | Carlos Martinez      | EasyGame                | Java       | 046   | 046   | 002   | 021   | 0066.44 ms     |
| 15th  | Stretch Maniac       | SmartBot                | Java       | 045   | 045   | 001   | 023   | 0068.65 ms     |
| 16th  | Docopoper            | RoboticOboeBotOboeTuner | Python2    | 044   | 044   | 000   | 025   | 0156.55 ms     |
| 17th  | Qwix                 | Analyst                 | Java       | 043   | 043   | 001   | 025   | 0069.06 ms     |
| 18th  | histocrat            | Analogizer              | Ruby       | 042   | 042   | 000   | 027   | 0038.58 ms     |
| 18th  | Thaylon              | Naan                    | Ruby       | 042   | 042   | 004   | 023   | 0038.48 ms     |
| 20th  | Thaylon              | NitPicker               | Ruby       | 041   | 041   | 000   | 028   | 0046.21 ms     |
| 20th  | bitpwner             | AlgorithmBot            | Python2    | 041   | 041   | 001   | 027   | 0025.34 ms     |
| 22nd  | histocrat            | WereVulcan              | Ruby       | 040   | 040   | 003   | 026   | 0038.41 ms     |
| 22nd  | Ourous               | QQ                      | Cobra      | 040   | 040   | 003   | 026   | 0089.33 ms     |
| 24th  | Stranjyr             | RelaxedBot              | Python2    | 039   | 039   | 001   | 029   | 0025.40 ms     |
| 25th  | JoshDM               | SelfLoathingBot         | Java       | 038   | 038   | 001   | 030   | 0068.75 ms     |
| 25th  | Ourous               | Q                       | Cobra      | 038   | 038   | 001   | 030   | 0094.04 ms     |
| 25th  | Ourous               | DejaQ                   | Cobra      | 038   | 038   | 001   | 030   | 0078.31 ms     |
| 28th  | Luis Mars            | Botzinga                | Java       | 037   | 037   | 002   | 030   | 0066.36 ms     |
| 29th  | kaine                | BoringBot               | Java       | 035   | 035   | 000   | 034   | 0066.16 ms     |
| 29th  | Docopoper            | OboeBeater              | Python2    | 035   | 035   | 002   | 032   | 0021.92 ms     |
| 29th  | Thaylon              | NaanViolence            | Ruby       | 035   | 035   | 003   | 031   | 0038.46 ms     |
| 32nd  | Martin Büttner       | SlowLizard              | Ruby       | 034   | 034   | 004   | 031   | 0038.32 ms     |
| 33rd  | Kyle Kanos           | ViolentBot              | Python3    | 033   | 033   | 001   | 035   | 0032.42 ms     |
| 34th  | HuddleWolf           | HuddleWolfTheConqueror  | .NET       | 032   | 032   | 001   | 036   | 0029.86 ms     |
| 34th  | Milo                 | DogeBotv2               | Java       | 032   | 032   | 000   | 037   | 0066.74 ms     |
| 34th  | Timmy                | DynamicBot              | Python3    | 032   | 032   | 001   | 036   | 0036.81 ms     |
| 34th  | mccannf              | YAARBot                 | JS         | 032   | 032   | 002   | 035   | 0100.12 ms     |
| 38th  | Stranjyr             | ToddlerProof            | Java       | 031   | 031   | 010   | 028   | 0066.10 ms     |
| 38th  | NonFunctional User2..| IHaveNoIdeaWhatImDoing  | Lisp       | 031   | 031   | 002   | 036   | 0036.26 ms     |
| 38th  | john smith           | RAMBOBot                | PHP        | 031   | 031   | 002   | 036   | 0014.53 ms     |
| 41st  | EoinC                | SimpleRandomBot         | .NET       | 030   | 030   | 005   | 034   | 0015.68 ms     |
| 41st  | Martin Büttner       | FairBot                 | Ruby       | 030   | 030   | 006   | 033   | 0038.23 ms     |
| 41st  | Docopoper            | OboeOboeBeater          | Python2    | 030   | 030   | 006   | 033   | 0021.93 ms     |
| 44th  | undergroundmonorail  | TheGamblersBrother      | Python2    | 029   | 029   | 000   | 040   | 0025.55 ms     |
| 45th  | DrJPepper            | MonadBot                | Haskel     | 028   | 028   | 002   | 039   | 0008.23 ms     |
| 46th  | Josef E.             | OneBehind               | Java       | 027   | 027   | 007   | 035   | 0065.87 ms     |
| 47th  | Ourous               | GitGudBot               | Cobra      | 025   | 025   | 001   | 043   | 0053.35 ms     |
| 48th  | ProgramFOX           | Echo                    | .NET       | 024   | 024   | 004   | 041   | 0014.81 ms     |
| 48th  | JoshDM               | SelfHatingBot           | Java       | 024   | 024   | 005   | 040   | 0068.88 ms     |
| 48th  | Trimsty              | Herpetologist           | Python3    | 024   | 024   | 002   | 043   | 0036.93 ms     |
| 51st  | Milo                 | DogeBot                 | Java       | 022   | 022   | 001   | 046   | 0067.86 ms     |
| 51st  | William Barbosa      | StarWarsFan             | Ruby       | 022   | 022   | 002   | 045   | 0038.48 ms     |
| 51st  | Martin Büttner       | ConservativeBot         | Ruby       | 022   | 022   | 001   | 046   | 0038.25 ms     |
| 51st  | killmous             | MAWBRBot                | Perl       | 022   | 022   | 000   | 047   | 0016.30 ms     |
| 55th  | Mikey Mouse          | LizardsRule             | .NET       | 020   | 020   | 007   | 042   | 0015.10 ms     |
| 55th  | ja72                 | BlindForesight          | .NET       | 020   | 020   | 001   | 048   | 0024.05 ms     |
| 57th  | robotik              | Evolver                 | Lua        | 019   | 019   | 001   | 049   | 0008.19 ms     |
| 58th  | Kyle Kanos           | LexicographicBot        | Python3    | 018   | 018   | 003   | 048   | 0036.93 ms     |
| 58th  | William Barbosa      | BarneyStinson           | Lua        | 018   | 018   | 005   | 046   | 0005.11 ms     |
| 60th  | Dr R Dizzle          | BartSimpson             | Ruby       | 017   | 017   | 001   | 051   | 0038.22 ms     |
| 60th  | jmite                | IocainePowder           | Ruby       | 017   | 017   | 003   | 049   | 0038.50 ms     |
| 60th  | ArcticanAudio        | SpockOrRock             | PHP        | 017   | 017   | 001   | 051   | 0014.19 ms     |
| 60th  | Dr R Dizzle          | BetterLisaSimpson       | Ruby       | 017   | 017   | 000   | 052   | 0038.23 ms     |
| 64th  | Dr R Dizzle          | LisaSimpson             | Ruby       | 016   | 016   | 002   | 051   | 0038.29 ms     |
| 65th  | Martin Büttner       | Vulcan                  | Ruby       | 015   | 015   | 001   | 053   | 0038.26 ms     |
| 65th  | Dr R Dizzle          | Khaleesi                | Ruby       | 015   | 015   | 005   | 049   | 0038.29 ms     |
| 67th  | Dr R Dizzle          | EdwardScissorHands      | Ruby       | 014   | 014   | 002   | 053   | 0038.21 ms     |
| 67th  | undergroundmonorail  | TheGambler              | Python2    | 014   | 014   | 002   | 053   | 0025.47 ms     |
| 69th  | cipher               | LemmingBot              | Python2    | 011   | 011   | 002   | 056   | 0025.29 ms     |
| 70th  | Docopoper            | ConcessionBot           | Python2    | 007   | 007   | 000   | 062   | 0141.31 ms     |
+-------+----------------------+-------------------------+------------+-------+-------+-------+-------+----------------+
Total Players: 70
Total Matches Completed: 2415
Total Tourney Time: 06:00:51.6877573

टूरनी नोट्स

• वू हू 70 बीओटीएस
• एमिल अभी भी KOTH के साथ है Ponyऔर उसका नया बॉट Dienstag3 का स्थान लेता है
• रॉय को उनके Gazzrबॉट के साथ 2 वें स्थान पर कूदने के लिए बधाई
• विलियम बारबोसा ने अपने बॉट के लिए क्विक ड्रा अवार्ड जीताBarneyStinson

• और स्लो पोक अवार्ड अपने बॉट्स के लिए डॉकोपॉपर को जाता है R.O.B.O.Tऔर Concessionbotजो दोनों> प्रति हाथ 140ms थे

• लॉग उपलब्ध @ https://github.com/eoincampbell/big-bang-game/blob/master/tourneys/Tournament-2014-08-01-23-24-00.zip?raw=true

निष्कासित बॉट

• BashRocksBot - अभी भी कोई खुशी नहीं है .net के साथ cygwin बैश स्क्रिप्ट निष्पादित
• CounterPreferenceBot - बग फिक्स की प्रतीक्षा कर रहा है
• बेतरतीब ढंग से - बग फिक्स का इंतजार
• CasinoShakespeare - को बाहर रखा गया है क्योंकि इसके लिए एक सक्रिय इंटरनेट कनेक्शन की आवश्यकता है

मूल पोस्ट प्रश्न

आप अपने दोस्तों के घर के आसपास रॉक, पेपर, कैंची, छिपकली, स्पॉक के सबसे महाकाव्य तसलीम लड़ाई के लिए आए हैं। सच बिगबैंग नेर्ड-टस्टिक शैली में, कोई भी खिलाड़ी खुद नहीं खेल रहा है, लेकिन अपनी ओर से खेलने के लिए कंसोल बॉट बनाए हैं। आप अपनी USB कुंजी को कोड़ा और तसलीम में शामिल करने के लिए शेल्डर विजेता को सौंप दें । पेनी झपट्टा मारती है। या शायद हॉवर्ड ने झपट्टा मारा। हम यहाँ लियोनार्ड के अपार्टमेंट में न्याय नहीं करते हैं।

नियम

स्टैंडर्ड रॉक, पेपर, कैंची, छिपकली, स्पॉक नियम लागू होते हैं।

• कैंची ने कागज को काट दिया
• पेपर रॉक को कवर करता है
• रॉक ने छिपकली को कुचल दिया
• छिपकली जहर Spock
• स्पोक स्केच कैंची
• कैंची छिपकली को नष्ट कर देती है
• छिपकली पेपर खाती है
• पेपर स्पॉक को नापसंद करता है
• Spock Rock को वाष्पित करता है
• रॉक कैंची को कुचलते हैं

प्रत्येक खिलाड़ी का बॉट टूर्नामेंट में एक दूसरे के खिलाफ एक मैच खेलेगा ।

प्रत्येक मैच में RPSLV गेम के 100 पुनरावृत्तियों शामिल होंगे।

प्रत्येक मैच के बाद, विजेता वह खिलाड़ी होता है जिसने 100 में से सर्वाधिक गेम / हाथ जीते हैं।

यदि आप एक मैच जीतते हैं, तो आपको लीग तालिका में 1 अंक दिया जाएगा। ड्रॉ-मैच के परिणाम में, न तो खिलाड़ी को एक अंक मिलेगा।

बीओटी आवश्यकताएँ

आपका बॉट कमांड लाइन से रन करने योग्य होना चाहिए।

शेल्डर के * निक्स बॉक्स की मृत्यु हो गई है, इसलिए हम इसे अपनी विंडोज़ 8 गेमिंग लैपटॉप से ​​बंद कर रहे हैं ताकि सुनिश्चित करें कि आपका प्रदान किया गया समाधान खिड़कियों पर चल सकता है। शेल्डर ने आपके समाधान को चलाने में सक्षम होने के लिए किसी भी आवश्यक रनटाइम को स्थापित करने के लिए विनम्रतापूर्वक पेश किया है। (.NET, जावा, पीएचपी, पायथन, रूबी, पॉवर्सशेल ...)

इनपुट

प्रत्येक मैच के पहले गेम में आपके बॉट को कोई तर्क नहीं दिया जाता है। प्रत्येक मैच के बाद के खेल में: - Arg1 में इस मैच में आपके बॉट्स हाथों / फैसलों का इतिहास होगा। - Arg2 में इस मैच में आपके विरोधियों के हाथों / फैसलों का इतिहास होगा।

इतिहास का प्रतिनिधित्व एकल कैपिटल अक्षरों के अनुक्रम द्वारा किया जाएगा जो आपके द्वारा संभावित हाथों का प्रतिनिधित्व कर सकते हैं।

 | R | Rock     |
 | P | Paper    |
 | S | Scissors |
 | L | Lizard   |
 | V | Spock    |

उदाहरण के लिए

• गेम 1: MyBot.exe
• गेम 2: MyBot.exe एसवी
• गेम 3: MyBot.exe एसएस वीएल
• गेम 4: MyBot.exe SSR VLS

उत्पादन

आपके बॉट को प्रत्येक खेल के लिए अपने "हाथ" का प्रतिनिधित्व करते हुए एक एकल वर्ण प्रतिक्रिया लिखनी होगी। परिणाम STDOUT को लिखा जाना चाहिए और बॉट को तब बाहर निकलना चाहिए। मान्य एकल पूंजी अक्षर नीचे हैं।

 | R | Rock     |
 | P | Paper    |
 | S | Scissors |
 | L | Lizard   |
 | V | Spock    |

उस स्थिति में जहां आपका बॉट एक वैध हाथ नहीं लौटाता है (यानी उपरोक्त 5 एकल पूंजी पत्रों में से 1, तो आप स्वचालित रूप से उस हाथ को जब्त कर लेते हैं और मैच जारी रहता है।

इस मामले में जहां दोनों बॉट एक वैध हाथ नहीं लौटाते हैं, तो खेल को एक ड्रॉ माना जाता है और मैच जारी रहता है।

मैच प्रारूप

प्रत्येक प्रस्तुत बॉट टूर्नामेंट में एक दूसरे के खिलाफ एक मैच खेलेगा।

प्रत्येक मैच बिल्कुल 100 गेम तक चलेगा।

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

एक एकल गेम के दौरान, ऑर्केस्ट्रेशन इंजन आपके बॉट को चलाएगा और आपके विरोधियों को 100 मिलीसेकंड अलग करेगा और फिर उसी भाषा / रनटाइम में किसी भी PRNG टकराव से बचने के लिए परिणामों की तुलना करेगा। (यह वास्तव में परीक्षण के दौरान मेरे साथ हुआ)।

जजिंग और अड़चनें

शेल्डर द कॉन्करर की आड़ में डॉ। शेल्डन कूपर ने टूर्नामेंट के संचालन की देखरेख करने की पेशकश की है। शेल्डर द कॉन्करर एक निष्पक्ष और बस ओवरसियर (ज्यादातर) है। शेल्डर के सभी निर्णय अंतिम होते हैं।

गेमिंग का आयोजन उचित और उचित तरीके से किया जाएगा:

• आपकी बॉट लिपि / कार्यक्रम एक सबफ़ोल्डर के तहत ऑर्केस्ट्रेशन इंजन में संग्रहीत किया जाएगा Players\[YourBotName]\
• आप Players\[YourBotName]\dataवर्तमान टूर्नामेंट से किसी भी डेटा या गेम इतिहास को लॉग इन करने के लिए सबफ़ोल्डर का उपयोग कर सकते हैं । प्रत्येक टूर्नामेंट चलाने की शुरुआत में डेटा निर्देशिकाओं को शुद्ध किया जाएगा।
• आप टूर्नामेंट में किसी अन्य खिलाड़ी की प्लेयर डायरेक्टरी तक नहीं पहुँच सकते
• आपके बॉट में विशिष्ट कोड नहीं हो सकता है जो किसी अन्य विशिष्ट बॉट व्यवहार को लक्षित करता है
• प्रत्येक खिलाड़ी एक से अधिक बॉट प्रस्तुत कर सकता है जब तक वे एक दूसरे से बातचीत या सहायता नहीं करते।

संपादित करें - अतिरिक्त बाधाएं

• Forfeits के बारे में, वे समर्थित नहीं होंगे। आपके बॉट को 5 वैध हाथों में से एक खेलना चाहिए। मैं टूर्नामेंट के बाहर प्रत्येक बॉट का परीक्षण कुछ यादृच्छिक डेटा के साथ करूँगा ताकि यह सुनिश्चित हो सके कि वे व्यवहार करते हैं। जो भी बोट एरर फेंकते हैं (यानी त्रुटियों को छोड़ देते हैं) वे बग फिक्स किए गए टूरिल टिल से बाहर कर दिए जाएंगे।
• बॉट्स तब तक व्युत्पन्न हो सकते हैं जब तक वे अपने व्यवहार में अलग-अलग होते हैं। बॉट (अन्य भाषाओं में) जो मौजूदा बॉट के समान व्यवहार करते हैं, उन्हें अयोग्य घोषित कर दिया जाएगा
• निम्नलिखित के लिए पहले से ही स्पैम बॉट हैं इसलिए कृपया पुनः सबमिट न करें
• • रॉक - बार्टिसम्पसन
• • पेपर - लिसासम्पसन
• • कैंची - एडवर्डसिसोरहैंड्स
• • स्पॉक - वल्कन
• • छिपकली - खलेसी
• • छद्म यादृच्छिक - SimpleRandomBot और FairBot
• • Psuedo रैंडम RPS - ConservativeBot
• • Psuedo रैंडम LV - बार्नी स्टिन्सन
• बोट्स 3 पार्टी सेवाओं या वेब संसाधनों (या कुछ और जो मैचों की गति / निर्णय लेने की गति को धीमा कर देता है) को कॉल नहीं कर सकते हैं। CasinoShakespeareएकमात्र अपवाद है कि बॉट को इस बाधा से पहले जमा किया गया था।

शेल्डर इस सवाल को जितनी बार टूर्नामेंट के परिणामों के साथ अपडेट करेगा, उतने अधिक बॉट प्रस्तुत किए जाएंगे।

ऑर्केस्ट्रेशन / कंट्रोल प्रोग्राम

ऑर्केस्ट्रेशन प्रोग्राम, प्रत्येक बॉट के लिए सोर्स कोड के साथ जीथब पर उपलब्ध है।

https://github.com/eoincampbell/big-bang-game

प्रस्तुत विवरण

आपके सबमिशन में शामिल होना चाहिए

• आपका बॉट का नाम
• तुम्हारा कोड
• की आज्ञा
  • अपने बॉट को शेल से निष्पादित करें
  • माणिक myBot.rb
  • python3 myBot.py
  • या
  • पहले अपने दोनों को संकलित करें और फिर निष्पादित करें। जैसे
  • csc.exe MyBot.cs
  • MyBot.exe

नमूना प्रस्तुतिकरण

BotName: SimpleRandomBot
Compile: "C:\Program Files (x86)\MSBuild\12.0\Bin\csc.exe" SimpleRandomBot.cs
Run:     SimpleRandomBot [Arg1] [Arg2]

कोड:

using System;
public class SimpleRandomBot
{
    public static void Main(string[] args)
    {
        var s = new[] { "R", "P", "S", "L", "V" };
        if (args.Length == 0)
        {
            Console.WriteLine("V"); //always start with spock
            return;
        }
        char[] myPreviousPlays = args[0].ToCharArray();
        char[] oppPreviousPlays = args[1].ToCharArray();
        Random r = new Random();
        int next = r.Next(0, 5);
        Console.WriteLine(s[next]);
    }
}

स्पष्टीकरण

कोई प्रश्न, नीचे टिप्पणी में पूछें।

Comments

जब एक खिलाड़ी ने हाथ धोया हो तो इतिहास कैसा दिखता है?

— हिस्टोक्रेट

मैं एक विश्लेषणात्मक दृष्टिकोण के साथ ऑल-आउट होने जा रहा था, लेकिन यहां के अधिकांश बॉट स्मार्ट एआई को हराने के लिए काफी बेवकूफ हैं।

— शराबी

सिर्फ इसलिए कि मैं कभी भी किसी भी कोठ चुनौती के लिए अग्रणी नहीं हूं, जिसमें मैंने प्रतिस्पर्धा की है, मैंने एक स्क्रीनशॉट को स्मृति चिन्ह के रूप में लिया है।

— काइल कानोस

मैं आज रात एक और टूमनी चलाऊंगा और पास्टबिन पर पूरे मैच के नतीजे पोस्ट करूंगा ... अगले बैच में लगभग 450 खेल होंगे लेकिन दौड़ने के लिए थोड़ा तेज होना चाहिए क्योंकि मैंने नियंत्रण ठेले में कुछ समानांतरकरण सामान लागू किया है

— इयोन कैंपबेल

अगर मैं गलत नहीं हूं, तो ऑर्केस्ट्रेशन स्क्रिप्ट में एक गंभीर बग प्रतीत होता है: खिलाड़ी 1 और 2 के इतिहास हमेशा बॉट्स को पहले और दूसरे तर्क के रूप में दिए जाते हैं, जबकि नियमों के अनुसार बॉट्स को हमेशा अपना होना चाहिए। पहला इतिहास। अब खिलाड़ी 2 प्रभावी रूप से खुद को हराने की कोशिश कर रहा है। (मुझे थोड़ा संदेह हुआ क्योंकि मेरे बॉट ने हर एक मैच जीता था जहाँ वह खिलाड़ी 1 था जबकि अन्य मैचों में से आधे से हार गया था।)

— एमिल

Answer 1

टट्टू (अजगर 2)

यह एक रॉक-पेपर-कैंची बॉट पर आधारित है जिसे मैंने कुछ समय पहले एक यूडेसिटी ऑनलाइन क्लास के अंत में एक प्रोग्रामिंग चुनौती के लिए लिखा था । मैंने इसे स्पॉक और छिपकली को शामिल करने के लिए बदल दिया और कुछ सुधार किए।

कार्यक्रम में 11 अलग-अलग सरल रणनीतियाँ हैं, जिनमें से प्रत्येक में 5 संस्करण हैं। यह इस आधार पर चुनता है कि उन्होंने अंतिम राउंड में कितना अच्छा प्रदर्शन किया होगा।

मैंने एक ऐसी कमबैक रणनीति निकाली जो सिर्फ मजबूत विरोधियों के खिलाफ यादृच्छिक थी। मुझे लगता है कि यह इस तरह से अधिक मजेदार है।

import sys

# just play Spock for the first two rounds
if len(sys.argv)<2 or len(sys.argv[1])<2: print 'V'; sys.exit()

# initialize and translate moves to numbers for better handling:
my_moves, opp_moves = sys.argv[1], sys.argv[2]
moves = ('R', 'P', 'S', 'V', 'L')   
history = zip([moves.index(i) for i in my_moves],
              [moves.index(i) for i in opp_moves])

# predict possible next moves based on history
def prediction(hist):
    N = len(hist)    

    # find longest match of the preceding moves in the earlier history
    cand_m = cand_o = cand_b = range(N-1)
    for l in xrange(1,min(N, 20)):
        ref = hist[N-l]
        cand_m = ([c for c in cand_m if c>=l and hist[c-l+1][0]==ref[0]]
                  or cand_m[-1:])
        cand_o = ([c for c in cand_o if c>=l and hist[c-l+1][1]==ref[1]]
                  or cand_o[-1:])
        cand_b = ([c for c in cand_b if c>=l and hist[c-l+1]==ref]
                  or cand_b[-1:])

    # analyze which moves were used how often
    freq_m, freq_o = [0]*5, [0]*5
    for m in hist:
        freq_m[m[0]] += 1
        freq_o[m[1]] += 1

    # return predictions
    return ([hist[-i][p] for i in 1,2 for p in 0,1]+   # repeat last moves
            [hist[cand_m[-1]+1][0],     # history matching of my own moves
             hist[cand_o[-1]+1][1],     # history matching of opponent's moves
             hist[cand_b[-1]+1][0],     # history matching of both
             hist[cand_b[-1]+1][1],
             freq_m.index(max(freq_m)), # my most frequent move
             freq_o.index(max(freq_o)), # opponent's most frequent move
             0])                        # good old rock (and friends)


# what would have been predicted in the last rounds?
pred_hist = [prediction(history[:i]) for i in xrange(2,len(history)+1)]

# how would the different predictions have scored?
n_pred = len(pred_hist[0])
scores = [[0]*5 for i in xrange(n_pred)]
for pred, real in zip(pred_hist[:-1], history[2:]):
    for i in xrange(n_pred):
        scores[i][(real[1]-pred[i]+1)%5] += 1
        scores[i][(real[1]-pred[i]+3)%5] += 1
        scores[i][(real[1]-pred[i]+2)%5] -= 1
        scores[i][(real[1]-pred[i]+4)%5] -= 1

# return best counter move
best_scores = [list(max(enumerate(s), key=lambda x: x[1])) for s in scores]
best_scores[-1][1] *= 1.001   # bias towards the simplest strategy    
if best_scores[-1][1]<0.4*len(history): best_scores[-1][1] *= 1.4
strat, (shift, score) = max(enumerate(best_scores), key=lambda x: x[1][1])
print moves[(pred_hist[-1][strat]+shift)%5]

ऐसे दोड़ो:

python Pony.py

संपादित करें : मैंने अनिश्चित मामलों में सबसे सरल रणनीति (यानी हमेशा एक ही चाल खेलने) के प्रति पूर्वाग्रह लगाकर एक छोटा बदलाव किया। यह थोड़ा जटिल पैटर्न खोजने की कोशिश नहीं करने में मदद करता है जहां कोई नहीं हैं, उदाहरण के लिए कंजर्वेटिवबॉट जैसे बॉट्स में।

नोट : मैंने मूल इतिहास मिलान रणनीति की व्याख्या करने की कोशिश की है जो इस बॉट का उपयोग मेरे अन्य बॉट डायनेस्टैग के लिए पोस्ट में है ।

Comments

96 प्रतिशत जीत अनुपात बकाया है।

— एंडोआन

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

— वचर्जिन

@Chargin, बिल्कुल। :) जब मैंने अपना मूल कोड लिखा था, तो मैंने कुछ साल पहले Iocaine Powder के बारे में पढ़ा था और सामान्य विचार को याद किया था। तो, पोनी वास्तव में इसके द्वारा प्रेरित है, यदि बहुत सीधे नहीं। जैसा कि यह पता चला है, वे बहुत समान हैं। मुझे लगता है कि मेरे पास रणनीतियों का एक व्यापक प्रदर्शन है, जबकि Iocaine पाउडर में मेटा-मेटा तर्क का एक चतुर स्तर है जो मुझे शामिल नहीं करता है।

— एमिल

Answer 2

मार्कोव, रूबी

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

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0 || (history = ARGV[1]).length < 3
    choices = ['R','P','S','L','V']
else
    markov = Hash.new []
    history.chars.each_cons(3) { |chars| markov[chars[0..1].join] += [chars[2]] }

    choices = []
    likely_moves = markov.key?(history[-2,2]) ? markov[history[-2,2]] : history.chars
    likely_moves.each { |move| choices += responses[move] }
end

puts choices.sample

जैसे दौड़ो

markov.rb

Comments

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

— जेमी

@ जैमी आप इस आदमी की तरह मतलब है? codegolf.stackexchange.com/a/35295/8478

— मार्टिन

आप यह अनुमान लगाते हैं। (टिप्पणी पोस्ट किए जाने के लिए लंबे समय तक पर्याप्त नहीं थी)

— जेमी

Answer 3

कंजरवेटिवबॉट, रूबी

नई चीजें बुरी चीजें हैं।

puts ['R','P','S'].sample

जैसे दौड़ो

ruby conservative.rb

Comments

ओजी संस्करण सबसे अच्छा संस्करण है।

— अधिकतम

Answer 4

स्टार वार्स फैन - रूबी

भाड़ में जाए तुम, स्पॉक

puts ['R','P','L','S'].sample

इसे ऐसे चलाएं:

ruby starwarsfan.rb

Comments

नियंत्रक में जोड़ा गया

— इयोन कैंपबेल

आप उत्तर संपादित करके रोलबैक कर सकते हैं - जब मैंने उन्हें जोड़ा है तो मैं यहाँ टिप्पणी करूँगा।

— इयोन कैंपबेल

क्यों आर और एस? : पी

— cjfaure

@ मर्दवी यह एक स्टार वार्स प्रशंसक है क्योंकि यह स्पॉक का उपयोग नहीं करता है।

— विलियम बारबोसा

आह, आप सही हैं (बेशक)। मैंने इसे बहुत तेजी से पढ़ा, मेरी गलती (लेकिन सौभाग्य के बिना परिणाम)

— मर्दवी

Answer 5

बार्नी स्टिन्सन - लुआ

मेरा केवल एक नियम है: नया हमेशा बेहतर होता है। पेंच पुराना जो केन पो या जो भी आप इसे कहते हैं।

math.randomseed(os.time())
print(math.random() > 0.5 and "V" or "L")

इसे ऐसे चलाएं:

lua legenwaitforitdary.lua

Answer 6

बोरिंग बॉट (जावा)

वह मानता है कि हर कोई हमेशा एक ही चीज निभाता है और उसी के अनुसार योजना बनाता है। वह आमतौर पर एक संबंध में चट्टानों को उठाता है, हालांकि 'इसलिए कि बाकी सब सही है?

public class BoringBot
{
    public static void main(String[] args)
    {
        int Rock=0;
        int Paper=0;
        int Scissors=0;
        int Lizard=0;
        int Spock=0;

        if (args.length == 0)
        {
            System.out.print("P");
            return;
        }

        char[] oppPreviousPlays = args[1].toCharArray();

        for (int j=0; j<oppPreviousPlays.length; j++) {
            switch(oppPreviousPlays[j]){
                case 'R': Rock++; break;
                case 'P': Paper++; break;
                case 'S': Scissors++; break;
                case 'L': Lizard++; break;
                case 'V': Spock++;
            }
        }

        int Best = Math.max(Math.max(Lizard+Scissors-Spock-Paper,
                                     Rock+Spock-Lizard-Scissors),
                            Math.max(Math.max(Paper+Lizard-Spock-Rock,
                                              Paper+Spock-Rock-Scissors),
                                     Rock+Scissors-Paper-Lizard));

        if (Best== Lizard+Scissors-Spock-Paper){
            System.out.print("R"); return;
        } else if (Best== Rock+Spock-Lizard-Scissors){
            System.out.print("P"); return;
        } else if (Best== Paper+Lizard-Spock-Rock){
            System.out.print("S"); return;
        } else if(Best== Paper+Spock-Rock-Scissors){
            System.out.print("L"); return;
        } else {
            System.out.print("V"); return;
        }
    }
}

Comments

ध्यान दें कि अगर यह एक रणनीति है कि कोई और पहले से ही मुझे बता रहा है और मैं हटा दूंगा। यह सिर्फ मुझे लगता है कि मैं पहले से ही नहीं देखा था की तरह लगता है।

— किउन

यह C # है। आप .length गुण गलत हैं। और कोई विधि नहींmax

— इयोन कैंपबेल

@EoinCampbell यह जावा है, मैं दोनों के साथ खेल रहा हूं और जाहिरा तौर पर भूल गया कि कौन सी कमांड किससे संबंधित है।

— 19

आह कूल। इसे मेरे पास छोड़ दो और मैं इसे शामिल कर लूंगा।

— इयोन कैंपबेल

अभी भी टूटा। jre8 चल रहा है - जावा BoringBot.java - त्रुटि: लगता है या लोड नहीं कर सका मुख्य वर्ग डी: \ My सॉफ्टवेयर देव \ बड़े धमाके-खेल \ BigBang.Orchestrator \ बिन \ डीबग \ खिलाड़ियों \ BoringBot \ BoringBot.java -

— इयोन कैम्पबेल

Answer 7

IocainePowder, रूबी

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

ध्यान दें कि मैंने अभी लिंक की गई रणनीति के मूल विचार को अनुकूलित किया है, इसका विस्तार से पालन नहीं किया है।

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0 || (history = ARGV[1]).length < 3
    choices = ['R','P','S','L','V']
else
    markov = Hash.new []
    history.chars.each_cons(3) { |chars| markov[chars[0..1].join] += [chars[2]] }

    choices = []
    likely_moves = markov.key?(history[-2,2]) ? markov[history[-2,2]] : history.chars
    likely_moves.each { |move| choices += responses[move] }
end

myChoice = choices.sample 
theirChoice = responses[myChoice].sample
actualChoice = responses[theirChoice].sample
puts actualChoice

जैसे दौड़ो

iocaine.rb

Comments

आप उस शब्द का इस्तेमाल जारी रखें। मुझे नहीं लगता कि इसका मतलब है कि आप क्या सोचते हैं इसका मतलब है।

— जोशीडीएम

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

— रॉय वान रिजन

आह, चतुर! झूठ मत बोलो, मैंने केवल मुझे वर्णित इओकेन सुना था, वास्तव में इसे विस्तार से नहीं देखा था। यदि आप चाहें तो अपना कोड संशोधित करें और क्रेडिट जमा करें और क्रेडिट प्राप्त करें!

— जमुई

Answer 8

HuddleWolfTheConqueror - C #

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

using System;
using System.Collections.Generic;
using System.Linq;

public class HuddleWolfTheConqueror
{

    public static readonly char[] s = new[] { 'R', 'P', 'S', 'L', 'V' };

    public static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine(pickRandom());
            return;
        }

        char[] myPlays = args[0].ToCharArray();
        char[] oppPlays = args[1].ToCharArray();

        char tryPredict = canPredictCounter(oppPlays);
        if (tryPredict != '^')
        {
            Console.WriteLine(tryPredict);
        }
        else
        {
            Console.WriteLine(pickRandom());
        }
        return;
    }


    public static char canPredictCounter(char[] history)
    {
        // don't predict if insufficient data
        if (history.Length < 5)
        {
            return '^';
        }

        // calculate probability of win for each choice
        Dictionary<char, double> dic = getBestProabability(history);

        // get item with highest probability of win
        List<char> maxVals = new List<char>();
        char maxVal = '^';
        double mostFreq = 0;
        foreach (var kvp in dic)
        {
            if (kvp.Value > mostFreq)
            {
                mostFreq = kvp.Value;
            }
        }
        foreach (var kvp in dic)
        {
            if (kvp.Value == mostFreq)
            {
                maxVals.Add(kvp.Key);
            }
        }

        // return error
        if (maxVals.Count == 0)
        {
            return maxVal;
        }

        // if distribution is not uniform, play best play
        if (maxVals.Count <= 3)
        {
            Random r = new Random(Environment.TickCount);
            return maxVals[r.Next(0, maxVals.Count)];
        }

        // if probability is close to uniform, use weighted dice roll
        if (maxVals.Count == 4)
        {
            return weightedRandom(dic);
        }

        // if probability is uniform, use random dice roll
        if (maxVals.Count >= 5)
        {
            return pickRandom();
        }

        // return error
        return '^';
    }

    public static Dictionary<char, double> getBestProabability(char[] history)
    {
        Dictionary<char, double> dic = new Dictionary<char, double>();
        foreach (char c in s)
        {
            dic.Add(c, 0);
        }
        foreach (char c in history)
        {
            if (dic.ContainsKey(c))
            {
                switch(c)
                {
                    case 'R' : 
                        dic['P'] += (1.0/(double)history.Length);
                        dic['V'] += (1.0/(double)history.Length);
                        break;
                    case 'P' : 
                        dic['S'] += (1.0/(double)history.Length);
                        dic['L'] += (1.0/(double)history.Length);
                        break;
                    case 'S' : 
                        dic['V'] += (1.0/(double)history.Length);
                        dic['R'] += (1.0/(double)history.Length);
                        break;
                    case 'L' : 
                        dic['R'] += (1.0/(double)history.Length);
                        dic['S'] += (1.0/(double)history.Length);
                        break;
                    case 'V' : 
                        dic['L'] += (1.0/(double)history.Length);
                        dic['P'] += (1.0/(double)history.Length);
                        break;
                    default : 
                        break;

                }
            }
        }
        return dic;
    }

    public static char weightedRandom(Dictionary<char, double> dic)
    {
        Random r = new Random(Environment.TickCount);
        int next = r.Next(0, 100);
        int curVal = 0;
        foreach (var kvp in dic)
        {
            curVal += (int)(kvp.Value*100);
            if (curVal > next)
            {
                return kvp.Key;
            }
        }
        return '^';
    }

    public static char pickRandom()
    {
        Random r = new Random(Environment.TickCount);
        int next = r.Next(0, 5);
        return s[next];
    }
}

Answer 9

ToddlerProof

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

संपादित करें :: यादृच्छिक थ्रो में कूदने के लिए आवश्यक एक हानि लकीर की लंबाई बदल गई। यादृच्छिक कूद के साथ एक प्रमुख बग भी तय किया।

के रूप में सहेजें ToddlerProof.java, संकलन करें, फिर चलाएंjava ToddlerProof [me] [them]

import java.util.HashMap;
public class ToddlerProof
{
    char[] moves = new char[]{'R', 'P', 'S', 'L', 'V'};
    public static void main(String[] args)
    {
        if(args.length<1) //first Round
        {
            System.out.print('V');//Spock is best
            return;
        }
        else
        {
            String them = args[1];
            String me = args[0];
            int streak = 0;

            HashMap<Character, Character> nextMove = new HashMap<Character, Character>();
            //Next move beats things that beat my last move
            nextMove.put('L', 'V');
            nextMove.put('V', 'S');
            nextMove.put('S', 'P');
            nextMove.put('P', 'R');
            nextMove.put('R', 'L');
            //Check if last round was a tie or the opponent beat me
            int lastResult = winner(me.charAt(me.length()-1), them.charAt(them.length()-1));
            if(lastResult == 0)
            {
                //tie, so they will chase my last throw
                System.out.print(nextMove.get(me.charAt(me.length()-1)));

                return;
            }
            else if(lastResult == 1)
            {
                //I won, so they will chase my last throw
                System.out.print(nextMove.get(me.charAt(me.length()-1)));


                return;
            }

            else{
                //I lost
                //find streak
                for(int i = 0; i<me.length(); i++)
                {
                    int a = winner(me.charAt(i), them.charAt(i));
                    if(a >= 0) streak = 0;
                    else streak++;
                }
                //check lossStreak
                //If the streak is 2, then a rotation will make it even.
                //if it is >2, something bad has happened and I need to adjust.
                if(streak>2)
                {
                    //if they are on to me, do something random-ish
                    int r = (((them.length()+me.length()-1)*13)/7)%4;
                    System.out.print(move[r]);
                    return;
                }
                //otherwise, go on with the plan
                System.out.print(nextMove.get(me.charAt(me.length()-1)));
                return;
            }
        }
    }
    public static int winner(char me, char them)
    {
        //check for tie
        if(me == them) return 0;
        //check if they won
        if(me=='V' && (them == 'L' || them == 'P')) return -1;
        if(me=='S' && (them == 'V' || them == 'R')) return -1;
        if(me=='P' && (them == 'S' || them == 'L')) return -1;
        if(me=='R' && (them == 'P' || them == 'V')) return -1;
        if(me=='L' && (them == 'R' || them == 'S')) return -1;
        //otherwise, I won
        return 1;
    }
}

Comments

क्या हमें प्रिंट या प्रिंटलाइन का उपयोग करना चाहिए? ... मैं निश्चित नहीं था।

— कीन जूल 25'14

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

— स्ट्रेंजजेयर

@Stranjyr आपके अंतिम रन में कुछ बग थे। यह नियंत्रण कार्यक्रम पर बमबारी नहीं करता था, लेकिन यदि आप "टॉडलरप्रोफ़ नाटकों एन" के लिए इतिहास खोजते हैं, तो ऐसा लगता है कि आपका बॉट कुछ हाथों के लिए अशक्त लौट रहा था और फिर हाथ को ऑटोलोज कर रहा था। उदाहरण का खेल "इको और टोडलरप्रोफ" है, जहां आपके बॉट को बाहर निकालने के लिए इको ने "LVSPRLV" खेला है।

— इयोन कैंपबेल

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

— स्ट्राँजियर

ठंडा। क्या यह अब नियंत्रण ठेले में अद्यतन किया गया है।

— इयोन कैंपबेल

Answer 10

बार्ट सिम्पसन

"अच्छी पुरानी चट्टान! कुछ भी नहीं धड़कता चट्टान!"

puts 'R'

ऐसे दोड़ो

ruby DoTheBartman.rb

---

लिसा सिम्पसन

"गरीब, पूर्वानुमान योग्य बार्ट। हमेशा रॉक चुनता है।"

puts 'P'

ऐसे दोड़ो

ruby LisaSimpson.rb

---

बेहतर लिसा सिम्पसन

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

puts ['P','V'].sample

ऐसे दोड़ो

ruby BetterLisaSimpson.rb

Comments

मामूली नाम का टकराव । वैसे भी +1।

— मार्टिन एंडर

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

— डॉ। आर डिज्ज़ले

शेल्डर सहमत हैं ... वहाँ एक बारबोट और एक बार्टिम्प्सन होगा :)

— इयोन कैंपबेल

हमारे पास केवल BortBot है।

— जोशमैड

ये मार्कोव द्वारा मारे जाएंगे :)

— क्रंचर

Answer 11

गूंज

C # में लिखा है। के साथ संकलित करें csc Echo.cs। दौड़ो ऐसे Echo.exe ARG1 ARG2।

पहला रन, इको एक यादृच्छिक विकल्प लेता है। हर रन पहले के बाद, इको बस प्रतिद्वंद्वी की नवीनतम कार्रवाई को दोहराता है।

using System;

namespace Echo
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                Random r = new Random();
                string[] options = new string[] { "R", "P", "S", "L", "V" };
                Console.WriteLine(options[r.Next(0, options.Length)]);
            }
            else if (args.Length == 2)
            {
                string opponentHistory = args[1];
                Console.WriteLine(opponentHistory[opponentHistory.Length - 1]);
            }
        }
    }
}

Answer 12

वल्कन, रूबी

मेरी उंगलियां आपस में चिपकी हुई हैं।

puts 'V'

जैसे दौड़ो

ruby vulcan.rb

(मुझे लगता है कि यह आपकी पृष्ठभूमि सेटिंग के लिए एकमात्र इन-कैरेक्टर रणनीति है।)

Comments

यह देखने के लिए कि क्या किसी का जन्म जीभ से हुआ है, एपिसोड को वापस देखने की जरूरत है। LizardMan FTW !!!

— इयोन कैंपबेल

लेकिन यह नहीं है कि कैसे बड़े धमाके पर हर कोई वैसे भी खेलता है?

— कीन जूल 25'14

@anotherguest "मैंने केवल यही कहा कि यह केवल चरित्र की रणनीति है"।

— मार्टिन एंडर

Answer 13

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

using System;
public class LizardsRule
{
    public static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("L");
            return;
        }
        char[] oppPreviousPlays = args[1].ToCharArray();
        var oppLen = oppPreviousPlays.Length;
        if (oppPreviousPlays.Length > 2
            && oppPreviousPlays[oppLen - 1] == 'R'
            && oppPreviousPlays[oppLen - 2] == 'R'
            && oppPreviousPlays[oppLen - 3] == 'R')
        {
            //It's an avalance, someone call Spock
            Console.WriteLine("V");
            return;
        }

        if (oppPreviousPlays.Length > 2
                && oppPreviousPlays[oppLen - 1] == 'S'
                && oppPreviousPlays[oppLen - 2] == 'S'
                && oppPreviousPlays[oppLen - 3] == 'S')
        {
            //Scissors, Drop your tail and pick up a rock
            Console.WriteLine("R");
            return;
        }

        //Unleash the Fury Godzilla
        Console.WriteLine("L");     
    }
}

Answer 14

बायेसियनबोट, पर्ल (अब v2!)

बाकी सब से ऊपर, यह एक अनूठा कार्यक्रम है। इसमें, आपको सांख्यिकी और भयानक प्रोग्रामिंग फॉर्म का शानदार संलयन दिखाई देगा। इसके अलावा, यह बोट शायद बायेसियन सांख्यिकी के कई नियमों को तोड़ता है, लेकिन नाम कूलर लगता है।

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

प्रत्येक मोड़, सभी लागू मॉडल (आमतौर पर 10) की भविष्यवाणियों को एक समग्र भविष्यवाणी बनाने के लिए एक साथ गुणा किया जाता है, जो तब यह निर्धारित करने के लिए उपयोग किया जाता है कि किन चालों में सबसे अधिक अनुमानित भुगतान है।

संपादन 1: इस संस्करण में, मैंने पूर्व वितरण को बदल दिया और बॉट को अधिक यादृच्छिक बना दिया जब यह खो रहा है।

कुछ चीजें हैं जो सुधार के अधीन हो सकती हैं, जैसे कि मॉडल की संख्या (250 केवल 3 अंकों की संख्या है), पूर्व वितरण की पसंद (वर्तमान में डीआर (3,3,3,3,3)), और फ्यूजन भविष्यवाणियों की विधि। इसके अलावा, मैंने कभी भी किसी भी संभावना वितरण को सामान्य करने की जहमत नहीं उठाई, जो अब के लिए ठीक है क्योंकि मैं उन्हें गुणा कर रहा हूं।

मुझे सुपर उच्च उम्मीदें नहीं हैं, लेकिन मुझे आशा है कि यह बॉट अच्छी तरह से करने में सक्षम होगा।

my ($phist, $ohist) = @ARGV;

my %text2num = ('R',0,'V',1,'P',2,'L',3,'S',4);  #the RVPLS ordering is superior
my @num2text = ('R','V','P','L','S');

@phist = map($text2num{$_},split(//,$phist));
@ohist = map($text2num{$_},split(//,$ohist));

$lowerlimit = 0;
for($lowerlimit..~~@phist-3){$curloc=$_;
 $result = $ohist[$curloc+2];
 @moveset = ($ohist[$curloc],$ohist[$curloc+1],$phist[$curloc],$phist[$curloc+1]);
 for(0..3){$a=$_;
  for(0..$a){$b=$_;
   $predict[$a][$b][$moveset[$a]][$moveset[$b]][$result]++;
  }
 }
}

@recentmoves = ($ohist[-2],$ohist[-1],$phist[-2],$phist[-1]);

@curpred = (1,1,1,1,1);

for(0..3){$a=$_;
 for(0..$a){$b=$_;
  for(0..4){$move=$_;
   $curpred[$move] *= $predict[$a][$b][$recentmoves[$a]][$recentmoves[$b]][$move]/3+1;
  }
 }
}

@bestmove = (0,0,0,0,0);
for(0..4){
 $bestmove[$_] = $curpred[$_]/2+$curpred[$_-1]+$curpred[$_-2];
}

$max = 0;
for(0..4){
 if($bestmove[$_]>$max){
  $max = $bestmove[$_];
 }
}
@options=();
$offset=0;
if(($ohist[-1] - $phist[-1])%5 < 2 && ($ohist[-2] - $phist[-2])%5 < 2 && ($ohist[-3] - $phist[-3])%5 < 2){  #frequentist alert!
 $offset=int(rand(3));
}
for(0..4){
 if($bestmove[$_] == $max){
  push(@options,$num2text[($_+$offset)%5]);
 }
}
$outputb = $options[int(rand(~~@options))];

print "$outputb";

मैं इस कार्यक्रम को ऐसे ही चला रहा हूं:

perl BayesianBot.plx

Answer 15

DynamicBot

डायनेमिक बॉट लगभग हमेशा बदलते रहते हैं। यह वास्तव में खुद को दोहराने से नफरत करता है

import sys, random
choices = ['L','V','S','P','R'] * 20
if len(sys.argv) > 1:
    my_history = sys.argv[1]
    [choices.remove(my_history[-1]) for i in range(15)]
print(choices[random.randrange(len(choices))])

भाषा: पायथन 3.4.1

आदेश: python dynamicbot.py <history>या python3 dynamicbot.py <history>आपके सिस्टम पर निर्भर करता है

Comments

हाँ, इस बारे में सोचा।

— देखिए

Answer 16

स्मार्टबोट - जावा

इस साइट पर किसी भी चीज़ के लिए मेरी पहली प्रविष्टि!

हालांकि बहुत रचनात्मक नाम नहीं है ...

स्मार्टबोट चालों के अनुक्रम पाता है जहां प्रतिद्वंद्वी और / या खुद की चालें पिछली चालों के समान होती हैं और तदनुसार योजना बनाती हैं।

name = SmartBot

मुझे लगता है कि इसे चलाना, गलत होने पर मुझे सुधारना।

java -jar SmartBot.jar

import java.util.ArrayList;
public class SmartBot {
    public static void main(String[] args) {
        if(args.length ==0){
            System.out.print("L");
            return;
        }
        if(args[0].length()<3){
            String[] randLetter = new String[]{"R","P","S","L","V"};
            System.out.print(randLetter[(int) Math.floor(Math.random()*5)]);
            return;
        }
        String myHistory = args[0];
        String otherHistory = args[1];

        double rScore,pScore,sScore,lScore,vScore;//score - highest = highest probability of next opponent move
        rScore = pScore = sScore = lScore = vScore = 0;
        lScore = .001;
        ArrayList<ArrayList<Integer>> moveHits = new ArrayList<ArrayList<Integer>>();
        for(int g = 0;g<2;g++){
            for(int i=1;i<(myHistory.length() / 2) + 1;i++){
                if(g==0){
                    moveHits.add(findAll(myHistory.substring(myHistory.length() - i),myHistory));
                }
                else{
                    moveHits.add(findAll(otherHistory.substring(otherHistory.length() - i),otherHistory));
                }
            }
            for(int i = 0; i < moveHits.size();i++){
                int matchingMoves = i+1;
                ArrayList<Integer> moveIndexes = moveHits.get(i);
                for(Integer index:moveIndexes){
                    if(index+matchingMoves +1<= otherHistory.length()){
                        char nextMove = otherHistory.charAt(index + matchingMoves-1);
                        if(nextMove=='R'){rScore = rScore + matchingMoves;}
                        if(nextMove=='P'){pScore = pScore + matchingMoves;}
                        if(nextMove=='S'){sScore = sScore + matchingMoves;}
                        if(nextMove=='L'){lScore = lScore + matchingMoves;}
                        if(nextMove=='V'){vScore = vScore + matchingMoves;}
                    }
                }
            }
        }
        if(rScore >= pScore && rScore >= sScore && rScore >= lScore && rScore >= vScore){
            System.out.print("V");
            return;
        }
        if(pScore >= rScore && pScore >= sScore && pScore >= lScore && pScore >= vScore){
            System.out.print("L");
            return;
        }
        if(sScore >= pScore && sScore >= rScore && sScore >= lScore && sScore >= vScore){
            System.out.print("R");
            return;
        }
        if(vScore >= pScore && vScore >= sScore && vScore >= lScore && vScore >= rScore){
            System.out.print("L");
            return;
        }
        if(lScore >= pScore && lScore >= sScore && lScore >= rScore && lScore >= vScore){
            System.out.print("S");
        }
        return;
    }
    public static ArrayList<Integer> findAll(String substring,String realString){
        ArrayList<Integer> ocurrences = new ArrayList<Integer>();
        Integer index = realString.indexOf(substring);
        if(index==-1){return ocurrences;}
        ocurrences.add(index+1);
        while(index!=-1){
            index = realString.indexOf(substring,index + 1);
            if(index!=-1){
                ocurrences.add(index+1);
            }
        }
        return ocurrences;
    }
}

यह प्रत्येक संभव अगले कदम के लिए एक अंक प्रदान करता है, इसी तरह के पैटर्न की संख्या से।

यह छिपकली को थोड़ा पसंद करता है।

Comments

मेरा मानना ​​है कि अगर आप इसे पहले जार करते हैं तो आप इसे कैसे चलाते हैं। यदि आप बस इसे पहले संकलित करते हैं, तो java ABotकाम करना चाहिए (सार्वजनिक वर्ग के समान फ़ाइल को नाम देना याद रखें)

— जस्टिन

धन्यवाद! अपेक्षाकृत नए प्रोग्रामर के रूप में मुझे इसकी जानकारी नहीं थी।

— स्ट्रेच

Answer 17

SpockOrRock - PHP

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

साथ दौड़ो php spockorrock.php

<?php

//Pick either Spock or Rock
if (rand(0,1) == 0)     echo("R\n");
else                    echo("V\n");


?>

Answer 18

धीरे-धीरे छिपकली, रूबी

छिपकली के साथ शुरू करने के बाद, यह हमेशा एक यादृच्छिक चाल चुनता है जो प्रतिद्वंद्वी के पिछले कदम को हरा देता है।

responses = {
  'R' => ['P', 'V'],
  'P' => ['S', 'L'],
  'S' => ['R', 'V'],
  'L' => ['S', 'R'],
  'V' => ['P', 'L']
}

if ARGV.length == 0
  puts 'L'
else
  puts responses[ARGV[1][-1]].sample
end

जैसे दौड़ो

ruby slowlizard.rb

Answer 19

LexicographicBot

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

import sys
import random

choices = ["L", "P", "R", "S", "V"]

total = len(sys.argv)
if total==1:
    print("L")
    sys.exit()

opponent = sys.argv[2]
opponent_last = opponent[-1]

if opponent_last == choices[-1]:
    print(random.choice(choices))
else:
    next = choices.index(opponent_last)+1
    print(choices[next])

यह विरोधी हाथ दूसरे से निपटने की उम्मीद है:

                           me
                            v
python LexicographicBot.py SR RV
                              ^
                            opponent

Comments

@ मार्टिनबटनर: कमान गयी! मैं काम में बहुत व्यस्त हो गया है कुछ प्रकाशित होने की कोशिश कर रहा है, इसलिए गायब हो गया।

— काइल कानोस

बिना किसी आर्ग के साथ पहले भाग पर ब्रेक। ट्रेसबैक (सबसे हालिया कॉल अंतिम): फ़ाइल "LexicographicBot \ LexicographicBot.py", लाइन 10, में <मॉड्यूल> प्रतिद्वंद्वी = sys.argv [2] IndexError: सूची सूचकांक सूची से बाहर

— ECL कैंपबेल

@EoinCampbell: मैं पहले रन पर एग्जिट क्लॉज भूल गया, यह जोड़ा गया है और अब ठीक काम करना चाहिए।

— काइल कानोस

Answer 20

वेरेवल्कन - रूबी

ऐसे दोड़ो ruby werevulcan.rb

@rules = {

  'L' => %w[V P],
  'P' => %w[V R],
  'R' => %w[L S],
  'S' => %w[P L],
  'V' => %w[R S]
}

@moves = @rules.keys

def defeats?(move1, move2)
  @rules[move1].include?(move2)
end

def score(move1, move2)
  if move1 == move2
    0
  elsif defeats?(move1, move2)
    1
  else
    -1
  end
end

def move
  player, opponent = ARGV

  # For the first 30 rounds, pick a random move that isn't Spock
  if player.to_s.size < 30
    %w[L P R S].sample
  elsif opponent.chars.to_a.uniq.size < 5
    exploit(opponent)
  else
    # Pick a random move that's biased toward Spock and against lizards
    %w[L P P R R S S V V V].sample
  end

end

def exploit(opponent)
  @moves.shuffle.max_by{ |m| opponent.chars.map{|o| score(m,o) }.reduce(:+) }
end

puts move

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

Answer 21

अनुगामी - रूबी

साथ चलाना ruby analogizer.rb। मैंने कोड के लिए एक लॉजिक फिक्स किया है, लेकिन इसमें कोई त्रुटि नहीं थी।

@rules = {

  'L' => %w[V P],
  'P' => %w[V R],
  'R' => %w[L S],
  'S' => %w[P L],
  'V' => %w[R S]
}

@moves = @rules.keys

def defeats?(move1, move2)
  @rules[move1].include?(move2)
end

def score(move1, move2)
  if move1 == move2
    0
  elsif defeats?(move1, move2)
    1
  else
    -1
  end
end

def move
  player, opponent = ARGV

  case player.to_s.size
  # Throw six lizards in the beginning to confuse opponent
  when 0..5
    'L'
  when 6
    'V'
  when 7
    'S'
  when 8
    'P'
  when 9
    'R'
  else
    analyze_history(player.chars.to_a, opponent.chars.to_a)
  end

end

def analyze_history(player, opponent)
  my_last_move = player.last
  predicted_moves = Hash.new {0}
  opponent_reactions = player.zip(opponent.drop(1))

  # Check whether opponent tended to make a move that would've beaten, lost, or tied my last move
  opponent_reactions.each do |my_move, reaction|
    score = score(reaction, my_move)
    analogous_moves = @moves.select { |move| score == score(move, my_last_move) }
    analogous_moves.each { |move| predicted_moves[move] += 1 }
  end

  # Assume if an opponent has never made a certain move, it never will
  @moves.each { |m| predicted_moves[m] = 0 unless opponent.include?(m) }

  # Pick the move with the best score against opponent's possible moves, weighted by their likelihood, picking randomly for ties
  @moves.shuffle.max_by{ |m| predicted_moves.map { |predicted, freq| score(m, predicted) * freq }.reduce(0,:+) }

end

puts move

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

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

Answer 22

जावा - SelfLoathingBot

BotName: SelfLoathingBot
Compile: Save as 'SelfLoathingBot.java'; compile.
Run:     java SelfLoathingBot [me] [them]

रैंड बेतरतीब ढंग से शुरू होता है, फिर यादृच्छिक रूप से जाने के लिए ~ 33%, या ~ 33% या तो तुरंत पूर्व के नाटकों के खिलाफ एक जीत रणनीति खेलने के लिए, जीत रणनीति के 50% विकल्प के साथ।

import java.util.Random;

public class SelfLoathingBot {

    static final Random RANDOM = new Random();

    private static char randomPlay() {

        switch (RANDOM.nextInt(5)) {

            case 0 : return 'R';

            case 1 : return 'P';

            case 2 : return 'S';

            case 3 : return 'L';

            default : return 'V';
        }
    }

    private static char antiPlay(String priorPlayString) {

        char[] priorPlays = priorPlayString.toCharArray();

        int choice = RANDOM.nextInt(2);

        switch (priorPlays[priorPlays.length - 1]) {

            case 'R' : return choice == 0 ? 'P' : 'V'; 

            case 'P' : return choice == 0 ? 'S' : 'L';

            case 'S' : return choice == 0 ? 'V' : 'R';

            case 'L' : return choice == 0 ? 'R' : 'S';

            default : return choice == 0 ? 'L' : 'P'; // V        
        }
    }

    public static void main(String[] args) {

        int choice = args.length == 0 ? 0 : RANDOM.nextInt(3);

        char play;

        switch (choice) {

            case 1 :

                // 33.3% chance Play myself
                play = antiPlay(args[0]);
                break;

            case 2 :

                // 33.3% chance Play opponent just in case opponent is screwy like that
                play = antiPlay(args[1]);
                break;

            default :

                // 33.3% chance 100% Random
                play = randomPlay();
        }

        System.out.print(play);
        return;
    }
}

Answer 23

विश्लेषक

विश्लेषक कुछ सामानों का विश्लेषण करता है और कुछ चीजें आपको हराने की कोशिश करता है।

साथ संकलन करें javac Analyst.javaऔर चलाएंjava Analyst

import java.util.Random;

public class Analyst{
    public static void main(String[] args){
        char action = 'S';

        try{
            char[] enemyMoves = null, myMoves = null;

            //first move is random
            if(args.length == 0){
                System.out.print(randomMove());
                System.exit(0);
            //moves 2-3 will beat their last move
            }else if(args[0].length() < 8){
                System.out.print(counterFor(args[1].charAt(args[1].length()-1)));
                System.exit(0);
            //following moves will execute some analyzation stuff
            }else{
                //get previous moves
                myMoves = args[0].toCharArray();
                enemyMoves = args[1].toCharArray();
            }

            //test if they're trying to beat our last move
            if(beats(enemyMoves[enemyMoves.length-1], myMoves[myMoves.length-2])){
                action = counterFor(counterFor(myMoves[myMoves.length-1]));
            }
            //test if they're copying our last move
            else if(enemyMoves[enemyMoves.length-1] == myMoves[myMoves.length-2]){
                action = counterFor(myMoves[myMoves.length-1]);
            }
            //else beat whatever they've done the most of
            else{
                action = counterFor(countMost(enemyMoves));
            }

            //if they've beaten us for the first 40 moves, do the opposite of what ive been doing
            if(theyreSmarter(myMoves, enemyMoves)){
                action = counterFor(action);
            }

        //if you break my program do something random
        }catch (Exception e){
            action = randomMove();
        }

        System.out.print(action);
    }

    private static char randomMove(){
        Random rand = new Random(System.currentTimeMillis());
        int randomMove = rand.nextInt(5);

        switch (randomMove){
            case 0: return 'R';
            case 1: return 'P';
            case 2: return 'S';
            case 3: return 'L';
            default: return 'V';
        }
    }

    private static char counterFor(char move){
        Random rand = new Random(System.currentTimeMillis());
        int moveSet = rand.nextInt(2);

        if(moveSet == 0){
            switch (move){
                case 'R': return 'P'; 
                case 'P': return 'S'; 
                case 'S': return 'R'; 
                case 'L': return 'R'; 
                default: return 'P';
            }
        }else{
            switch (move){
                case 'R': return 'V'; 
                case 'P': return 'L'; 
                case 'S': return 'V'; 
                case 'L': return 'S'; 
                default: return 'L';
            }
        }
    }

    private static boolean beats(char move1, char move2){
        if(move1 == 'R'){
            if((move2 == 'S') || (move2 == 'L')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'P'){
            if((move2 == 'R') || (move2 == 'V')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'S'){
            if((move2 == 'L') || (move2 == 'P')){
                return true;
            }else{
                return false;
            }
        }else if(move1 == 'L'){
            if((move2 == 'P') || (move2 == 'V')){
                return true;
            }else{
                return false;
            }
        }else{
            if((move2 == 'R') || (move2 == 'S')){
                return true;
            }else{
                return false;
            }
        }
    }

    private static char countMost(char[] moves){
        int[] enemyMoveList = {0,0,0,0,0};

        for(int i=0; i<moves.length; i++){
            if(moves[i] == 'R'){
                enemyMoveList[0]++;
            }else if(moves[i] == 'P'){
                enemyMoveList[1]++;
            }else if(moves[i] == 'S'){
                enemyMoveList[2]++;
            }else if(moves[i] == 'L'){
                enemyMoveList[3]++;
            }else if(moves[i] == 'V'){
                enemyMoveList[4]++;
            }
        }

        int max = 0, maxIndex = 0;
        for(int i=0; i<5; i++){
            if(enemyMoveList[i] > max){
                max = enemyMoveList[i];
                maxIndex = i;
            }
        }

        switch (maxIndex){
            case 0: return 'R';
            case 1: return 'P';
            case 2: return 'S';
            case 3: return 'L';
            default: return 'V';
        }
    }

    private static boolean theyreSmarter(char[] myMoves, char[] enemyMoves){
        int loseCounter = 0;

        if(enemyMoves.length >= 40){
            for(int i=0; i<40; i++){
                if(beats(enemyMoves[i],myMoves[i])){
                    loseCounter++;
                }
            }
        }else{
            return false;
        }

        if(loseCounter > 20){
            return true;
        }else{
            return false;
        }
    }
}

Answer 24

जुआरी - अजगर 2

import sys
import random

MODE = 1

moves = 'RSLPV'

def element_sums(a, b):
    return [a[i] + b[i] for i in xrange(len(a))]

def move_scores(p):
    def calc(to_beat):
        return ['LDW'.find('DLLWW'[moves.find(m)-moves.find(to_beat)]) for m in moves]

    return dict(zip(moves, element_sums(calc(p[0]), calc(p[1]))))

def move_chooser(my_history, opponent_history):
    predict = sorted(moves, key=opponent_history.count, reverse=MODE)[-2:]
    scores = move_scores(predict)
    return max(scores, key=lambda k:scores[k])

if __name__ == '__main__':
    if len(sys.argv) == 3:
        print move_chooser(*sys.argv[1:])
    elif len(sys.argv) == 1:
        print random.choice(moves)

नाम के विपरीत, इस कार्यक्रम में केवल समय यादृच्छिकता का उपयोग किया जाता है, जब कोई जानकारी नहीं होती है। इसके बजाय, यह जुआरी के पतन का नाम दिया गया है, यह विश्वास कि यदि कोई यादृच्छिक घटना अतीत में कम बार हुई है, तो भविष्य में ऐसा होने की अधिक संभावना है। उदाहरण के लिए, यदि आप 20 बार एक उचित सिक्का फ्लिप करते हैं, और पहले 15 प्रमुख हैं, तो जुआरी की कमजोरी बताती है कि शेष फ़्लिप होने की संभावना बढ़ जाती है। बेशक, यह असत्य है; पिछले फ्लैप्स की परवाह किए बिना, मेल खाने के लिए एक उचित सिक्के की संभावना हमेशा 50% होती है।

यह कार्यक्रम प्रतिद्वंद्वी के इतिहास का विश्लेषण करता है, उन 2 चालों का पता लगाता है जिन्हें उसने अब तक कम से कम इस्तेमाल किया है, और यह मानता है कि इस बार प्रतिद्वंद्वी की चाल उन दो में से एक होगी। एक जीत के लिए 2, एक ड्रॉ के लिए 1 और एक हार के लिए 0, यह इन दो भविष्यवाणी की चाल के खिलाफ अधिकतम स्कोर के साथ चाल पाता है और फेंकता है।

जुआरी का भाई - अजगर 2

import sys
import random

MODE = 0

moves = 'RSLPV'

def element_sums(a, b):
    return [a[i] + b[i] for i in xrange(len(a))]

def move_scores(p):
    def calc(to_beat):
        return ['LDW'.find('DLLWW'[moves.find(m)-moves.find(to_beat)]) for m in moves]

    return dict(zip(moves, element_sums(calc(p[0]), calc(p[1]))))

def move_chooser(my_history, opponent_history):
    predict = sorted(moves, key=opponent_history.count, reverse=MODE)[-2:]
    scores = move_scores(predict)
    return max(scores, key=lambda k:scores[k])

if __name__ == '__main__':
    if len(sys.argv) == 3:
        print move_chooser(*sys.argv[1:])
    elif len(sys.argv) == 1:
        print random.choice(moves)

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

तो हां, ये दो कार्यक्रम केवल एक चरित्र के अलावा हैं। :)

Comments

TheGambler MODE को किस स्थिति में बदलता है?

— डॉ। आर डिज्ज़ल

@DrRDizzle ऐसा नहीं है, ऐसा लगता है कि यह एक में दो बॉट का एक जमा है।

— पाओलो एबरमन जुएल

यदि आप एक पंक्ति में एक निश्चित समय से अधिक समय खो देते हैं तो क्या यह प्रोग्राम अधिक प्रभावी नहीं होगा?

— डॉ। आर डिज़ल

Answer 25

डायनस्टैग (पायथन 2)

मेरी पहली प्रविष्टि पोनी अपने सभी दूसरे अनुमानों (ट्रिपल अनुमान, ...) और मेटा तर्क के साथ काफी अच्छी तरह से किराया लगती है। लेकिन क्या यह जरूरी भी है?

तो, यहाँ Dienstag है, Pony का छोटा दोस्त, केवल 55 रणनीतियों में से एक: प्रतिद्वंद्वी के अगले कदम की भविष्यवाणी करें और इसे हरा दें।

वर्तमान लीडरबोर्ड के शीर्ष दस में हर बॉट के साथ लंबे समय तक डिएनस्टैग जीत या संबंध रहा है। टट्टू को छोड़कर जो है।

import sys
if len(sys.argv)<2 or len(sys.argv[1])<2: print 'L'; sys.exit()
hist = [map('RPSVL'.index, p) for p in zip(sys.argv[1], sys.argv[2])]
N = len(hist)
cand = range(N-1)
for l in xrange(1,N):
    cand = ([c for c in cand if c>=l and hist[c-l+1]==hist[-l]] or cand[-1:])
print 'RPSVL'[(hist[cand[-1]+1][1]+(1,3)[N%2==0])%5]

ऐसे दोड़ो:

python Dienstag.py

मैं मानता हूं कि यह कोड थोड़ा मोटा है। क्या किसी को इसके बारे में अधिक जानने की परवाह करनी चाहिए, मैं स्पष्टीकरण जोड़ सकता हूं।

संपादित करें: इस विचार को समझाने के लिए एक छोटा सा उदाहरण वॉकथ्रू है:

• इस कार्यक्रम का इतिहास खुद का है और प्रतिद्वंद्वी की चालें:

  sys.arg[1] = 'LLVLLVL', sys.arg[2] = 'RPSPSSP'

• इतिहास को जोड़ियों की सूची में जोड़ा जाता है और चालों का अनुवाद संख्याओं में किया जाता है (R = 0, ...):

  hist = [[4, 0], [4, 1], [3, 2], [4, 1], [4, 2], [3, 2], [4, 1]]

• अब तक खेले गए राउंड की संख्या निर्धारित की गई है:

  N = 7

• मूल विचार अब पहले के इतिहास में सबसे अंतिम चालों की सबसे लंबी अखंड श्रृंखला की तलाश है। कार्यक्रम इस बात पर नज़र रखता है कि सूची में cand(उम्मीदवारों के लिए) ऐसी श्रृंखला कहाँ समाप्त होती है । शुरुआत में, जाँच के बिना, पिछले एक को छोड़कर इतिहास में हर स्थिति पर विचार किया जाता है:

  cand = [0, 1, 2, 3, 4, 5]

• अब संभव श्रृंखलाओं की लंबाई कदम दर कदम बढ़ाई जाती है। श्रृंखला की लंबाई के लिए l = 1यह अंतिम चाल जोड़ी की पिछली घटनाओं के लिए दिखता है [4, 1]। यह इतिहास की स्थिति में पाया जा सकता है 1और 3। केवल इन्हें candसूची में रखा गया है :

  cand = [1, 3]

• इसके बाद, l = 2यह जांचने के लिए कि कौन से संभावित उम्मीदवार दूसरे से अंतिम चाल जोड़ी से पहले थे [3, 2]। यह केवल स्थिति के लिए मामला है 3:

  cand = [3]

• के लिए l = 3और अधिक उस लंबाई की कोई पिछली श्रृंखला नहीं है और candखाली होगी। इस मामले में अंतिम तत्व candरखा गया है:

  cand = [3]

• बॉट अब मानता है कि इतिहास दोहराएगा। पिछली बार जब कैन [3, 2], [4, 1]हुआ था, उसके बाद यह हुआ था [4, 2]। तो, प्रतिद्वंद्वी 2(कैंची) खेला (पिटाई (2+1)%5 = 3) या (2+3)%5 = 0(रॉक) द्वारा पीटा जा सकता है । बॉट जवाब देता है, पहले या दूसरे विकल्प के आधार पर कि क्या Nविषम है या यहां तक ​​कि बस कुछ विचरण शुरू करने के लिए।

• यहाँ कदम 3चुना जाता है जिसे बाद में वापस अनुवादित किया जाता है:

  print 'V'

नोट: एन दौर के बाद अगले कदम को वापस करने के लिए डायनेस्टैग में समय जटिलता हे ( एन ² ) है । पोनी में समय जटिलता O ( N ³ ) है। इसलिए इस पहलू में वे शायद बहुत खराब हैं तो अधिकांश अन्य प्रविष्टियाँ हैं।

Comments

कृपया कीजिए। यह मेरे लिए सीखने का एक शानदार अनुभव है। मैं आमतौर पर सी # / जावा भूमि में रहता हूं इसलिए सभी लुआ, रूबी, अजगर, हैसेल पागलपन मेरे लिए बहुत दिलचस्प है।

— इयोन कैंपबेल

मुझे खेलों में पोनी का एक अतिरिक्त उदाहरण जोड़ने का भी शौक है। यह 3 जी करने के लिए अंतिम नश्वर स्तर स्तरों में अपने दर्पण से लड़ने के लिए हो;;

— इयॉन कैंपबेल

@EoinCampbell :-) कम से कम सीधा मैच पोनी बनाम पोनी एक आदर्श ड्रॉ होगा। मेरे दोनों बॉट्स में यादृच्छिकता का कोई तत्व नहीं है।

— एमिल

Answer 26

बैश रॉक्स

क्या साइबरविन एक रनटाइम के रूप में पूछने के लिए बहुत अधिक है?

bashrocks.sh:

#!/bin/bash
HAND=(R P S L V)
RAND=`od -A n -t d -N 1 /dev/urandom | xargs`
echo ${HAND[ $RAND  % 5 ]}

और इसे ऐसे चलाएं:

sh bashrocks.sh

Comments

शीर्षक पढ़ने के बाद, मैं थोड़ा निराश है कि आप कुछ भी लेकिन ऐसा कर रहा हूँ R। ;)

— मार्टिन एंडर

@mccannf। इस एक के साथ कुछ समस्याएँ हैं ... मैंने साइबरविन को स्थापित किया है और अपनी स्क्रिप्ट को पूरी तरह से योग्य पथों के साथ संशोधित करके C: \ Cygwin \ bin को od.exe, xargs.exe & echo.exe के लिए संशोधित किया है। अभी भी निम्नलिखित त्रुटि हो रही है। C: / Cygwin / bin / xargs: echo: No no file or directory% 5 ") सिंटैक्स त्रुटि: ऑपरेंड अपेक्षित (त्रुटि टोकन है"

— इयोन कैंपबेल

@EoinCampbell - जब आप विंडोज़ में फाइल बनाते हैं, तो क्या आप उसे dos2unixक्रियान्वित करने से पहले साइबरविन में फाइल पर चला सकते हैं ?

— 21

ज़रूर। मैं कोशिश करूँगा।

— इयोन कैंपबेल

मुझे लगता है कि समस्या

— इयोन कैंपबेल

Answer 27

कलन विधि

एक होने के लिए एक एल्गोरिथ्म।

Cuz 'यह हमेशा कुछ करने के लिए सुरक्षित महसूस करता है, और अधिक जटिल बेहतर है।

अभी तक कुछ गंभीर गणित नहीं किया गया है, इसलिए यह एल्गोरिथ्म उतना प्रभावी नहीं हो सकता है।

import random, sys

if __name__ == '__main__':

    # Graph in adjacency matrix here
    graph = {"S":"PL", "P":"VR", "R":"LS", "L":"VP", "V":"SR"}
    try:
        myHistory = sys.argv[1]
        opHistory = sys.argv[2]
        choices = ""

        # Insert some graph stuff here. Newer versions may include advanced Math.
        for v in graph:
            if opHistory[-1] == v:
                for u in graph:
                    if u in graph[v]:
                        choices += graph[u]

        print random.choice(choices + opHistory[-1])

    except:
        print random.choice("RPSLV")

पायथन 2 कार्यक्रम: python algorithm.py

Comments

इस एल्गोरिथ्म का सारांश: यह देखें कि प्रतिद्वंद्वी ने आखिरी बार क्या खेला था, और फिर बेतरतीब ढंग से दो चालों में से एक खेलते हैं जो प्रतिद्वंद्वी के आखिरी कदम के खिलाफ हार जाएगा अगर वे इसे फिर से खेलते हैं। तो यह बॉट्स के खिलाफ बेहतर है जो एक पंक्ति में दो बार एक ही चाल नहीं खेलते हैं।

— रोरी ओ'केन

Haha। मैं वास्तव में नहीं जानता कि क्या मैंने इसे इस तरह से बनाया है। अगर मैं गलत नहीं हूं, तो यह वास्तव में 5 चालों में से किसी को भी बेतरतीब ढंग से चुनने का एक जटिल तरीका है। ;)

— वेक्टर

Answer 28

फेयरबॉट, रूबी

चलो सरल शुरू करते हैं।

puts ['R','P','S','L','V'].sample

जैसे दौड़ो

ruby fairbot.rb

Comments

उस अंतिम 'वी' परम पर छोटे टाइपो। अगर आप पूर्णता के लिए अद्यतन करना चाहते हैं, तो इसे मायसाइड पर तय कर दिया है

— इयोन कैंपबेल

@ EoinCampbell धन्यवाद, तय!

— मार्टिन एंडर

दिलचस्प बात यह है कि इसके पास ऑल स्ट्रेटेजी के मुकाबले जीतने के बराबर आसार हैं।

— क्रंचर

Answer 29

ViolentBot

यह बॉट विरोधियों की पिछली पसंद के आधार पर सबसे हिंसक विकल्प चुनता है:

import sys

choice_dict = {"L" : "S", "P" : "S", "R" : "V", "S" : "V", "V" : "L"}

total = len(sys.argv)
if total==1:
    print("L")
    sys.exit()

opponent = sys.argv[2]
opponent_last = opponent[-1]

print(choice_dict[opponent_last])

ऐसे दोड़ो

python ViolentBot.py (me) (opp)

Comments

कोई पैराम नहीं है। ट्रेसबैक (सबसे हालिया कॉल अंतिम): फ़ाइल "ViolentBot \ ViolentBot.py", लाइन 9, में <मॉड्यूल> प्रतिद्वंद्वी = sys.argv [2] IndexError: सूची अनुक्रमणिका को सीमा से बाहर

— EPA कैंपबेल

परम के साथ टूट जाता है। ट्रैसबैक (सबसे हाल कॉल पिछले): फ़ाइल "ViolentBot \ ViolentBot.py", रेखा 12, <मॉड्यूल> प्रिंट (choice_dict [opponent_last]) KeyError में: 'एस'

— इयोन कैम्पबेल

@EoinCampbell: मैंने पहले रन के लिए एक एक्जिट क्लॉज जोड़ा है, आपको इसे अभी चलाने में सक्षम होना चाहिए।

— काइल कानोस

Answer 30

हास्केल - मोनाडबोट

मुझे नहीं पता कि अगर ghc को "कारण के भीतर" माना जाता है, लेकिन चलो मान लेते हैं कि यह है। इस बॉट की रणनीति अपने प्रतिद्वंद्वी के सबसे लोकप्रिय कदम का मुकाबला करना है।

Compile: ghc monadbot.hs
Run:     ./monadbot [Arg1] [Arg2]

कोड:

import System.Environment
import Data.List
import Data.Ord

main :: IO ()
main = do
  args <- getArgs
  let moves = if not (null args) then args !! 1 else ""
      fave = if not (null moves) then head $ maximumBy (comparing length) (group $ sort moves) else 'V'
  putChar $ case fave of 'R' -> 'P'
                         'P' -> 'S'
                         'S' -> 'R'
                         'L' -> 'R'
                         'V' -> 'P'
                         _   -> 'V'