রক, পেপার, কাঁচি, টিকটিকি, মহাকাব্যের স্পক টুর্নামেন্ট

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 বটস
• এমিল এখনও কোথাকার Ponyএবং তার নতুন বটটি Dienstagতৃতীয় স্থান অধিকার করে
• রয়কে তার Gazzrবট নিয়ে ২ য় স্থানে লাফানোর জন্য অভিনন্দন
• উইলিয়াম বার্বোসা তার বটের জন্য কুইক ড্র পুরস্কার জিতলেনBarneyStinson

• এবং স্লো পোকে পুরষ্কার ডকোপ্পারের কাছে যায় তার বটগুলির জন্য R.O.B.O.Tএবং Concessionbotযারা উভয়ই ছিলেন> প্রতি হাত 140 ডলার

• লগগুলি উপলভ্য @ https://github.com/eoincampbell/big-bang-game/blob/master/tourney/ টুর্নামেন্ট 20144-08-01-23-24-00.zip?raw=true

বাদ দেওয়া বটস

• বাশআরকসবট -। নেট চালানো সাইগউইন বাশ স্ক্রিপ্ট নিয়ে কোনও আনন্দ নেই
• কাউন্টারপ্রেফারেন্সবট - বাগ ফিক্সের অপেক্ষায়
• এলোমেলোভাবে আলোকিত - বাগ ফিক্সের অপেক্ষায়
• ক্যাসিনো শেক্সপীয়ার - বাদ পড়ে কারণ এটির জন্য একটি সক্রিয় ইন্টারনেট সংযোগ প্রয়োজন

মূল পোস্ট করা প্রশ্ন

রক, পেপার, কাঁচি, টিকটিকি, স্পোকের সর্বকালের মহাকাব্য শোডাউন যুদ্ধের জন্য আপনি আপনার বন্ধুদের বাড়িতে ঘুরেছেন। সত্য বিগব্যাং নার্ড-টেস্টিক স্টাইলে, খেলোয়াড়দের কেউই নিজেরাই খেলছে না তবে তাদের হয়ে খেলতে কনসোল বট তৈরি করেছে। শোডাউনটিতে অন্তর্ভুক্তির জন্য আপনি নিজের ইউএসবি কীটি চাবুক ফেলে শেল্ডার দ্য কনকোভারারকে দিয়ে দেন। পেনি বয়। অথবা সম্ভবত হাওয়ার্ড sooons। আমরা এখানে লিওনার্ডের অ্যাপার্টমেন্টে বিচার করি না।

বিধি

স্ট্যান্ডার্ড রক, পেপার, কাঁচি, টিকটিকি, স্পকের বিধি প্রযোজ্য।

• কাঁচি কাগজ কাটা
• কাগজ রক কভার
• রক টিকটিকি টুকরো টুকরো করে
• টিকটিকি বিষ স্পোক
• স্পোক কাঁচি ধাক্কা
• কাঁচি টিকটিক করে টিকটিকি
• টিকটিকি কাগজ খায়
• কাগজ স্পোককে অস্বীকার করে
• স্পক রককে বাষ্প দেয়
• রক কাঁচি ক্রাশ

প্রতিটি খেলোয়াড়ের বট টুর্নামেন্টে একে অপরের বিরুদ্ধে এক ম্যাচ খেলবে ।

প্রতিটি মিল একটি আরপিএসএলভি গেমের 100 টি পুনরাবৃত্তি নিয়ে গঠিত।

প্রতিটি ম্যাচের পরে, বিজয়ী সেই খেলোয়াড় যিনি 100 এর মধ্যে সর্বাধিক গেম / হাত জিতেছেন।

আপনি যদি কোনও ম্যাচ জিতেন, আপনাকে লিগ টেবিলের 1 পয়েন্ট দেওয়া হবে। ড্র ম্যাচের ফলস্বরূপ, কোনও খেলোয়াড়ই একটি পয়েন্ট অর্জন করতে পারবে না।

বট প্রয়োজনীয়তা

আপনার বটটি অবশ্যই কমান্ড লাইন থেকে চালানো যাবে।

শেল্ডারের * নিক্স বাক্সটি মারা গেছে, সুতরাং আমরা এটি তার উইন্ডোজ 8 গেমিং ল্যাপটপের বাইরে চালাচ্ছি যাতে আপনার প্রদত্ত সমাধানটি উইন্ডোতে চালিত হতে পারে তা নিশ্চিত হন। শেল্ডার দয়া করে আপনার সমাধানটি চালাতে সক্ষম হওয়ার জন্য প্রয়োজনীয় কোনও রানটাইমগুলি (কারণগুলির মধ্যে) ইনস্টল করার প্রস্তাব দিয়েছেন। (। নেট, জাভা, পিএইচপি, পাইথন, রুবি, পাওয়ারশেল ...)

ইনপুট

প্রতিটি ম্যাচের প্রথম খেলায় আপনার বটকে কোনও যুক্তি সরবরাহ করা হয় না। প্রতিটি ম্যাচের প্রতিটি পরবর্তী খেলায়: - আরগ 1 এই ম্যাচে আপনার বট হ্যান্ডস / সিদ্ধান্তের ইতিহাস থাকবে। - আরগ 2 এ এই ম্যাচে আপনার বিরোধীদের হাত / সিদ্ধান্তের ইতিহাস থাকবে।

ইতিহাস আপনি খেলতে পারবেন এমন সম্ভাব্য হাতের প্রতিনিধিত্ব করে একক মূলধন অক্ষরের ক্রম দ্বারা উপস্থাপিত হবে।

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

যেমন

• গেম 1: মাইবট.এক্স
• গেম 2: মাইবট.এক্সি এসভি
• খেলা 3: মাইবট.এক্সি এসএস ভিএল
• গেম 4: মাইবট.এক্সি এসএসআর ভিএলএস

আউটপুট

আপনার বটকে প্রতিটি গেমের জন্য "হাত" উপস্থাপন করে একটি একক অক্ষর প্রতিক্রিয়া লিখতে হবে। ফলাফলটি STDOUT এ লিখতে হবে এবং বটটি প্রস্থান করতে হবে। বৈধ একক মূলধনের অক্ষর নীচে রয়েছে।

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

যে ক্ষেত্রে আপনার বটটি বৈধ হাত ফেরত দেয় না (যেমন উপরের 5 টি একক মূলধনের অক্ষরের 1 টি), তাহলে আপনি স্বয়ংক্রিয়ভাবে সেই হাতটি জব্দ করলেন এবং ম্যাচটি অবিরত থাকবে।

ক্ষেত্রে যেখানে উভয় বটই বৈধ হাত ফেরায় না, তারপরে খেলাটিকে একটি ড্র হিসাবে বিবেচনা করা হয় এবং ম্যাচটি অব্যাহত থাকে।

ফর্ম্যাট ম্যাচ

প্রতিটি জমা দেওয়া বট টুর্নামেন্টে একে অপরের বিরুদ্ধে একটি ম্যাচ খেলবে।

প্রতিটি ম্যাচ ঠিক 100 গেম চলবে।

ম্যাচগুলি বেনামে খেলানো হবে, আপনি যে নির্দিষ্ট বটের বিরুদ্ধে খেলছেন সে সম্পর্কে আপনার কাছে উন্নত জ্ঞান থাকবে না, তবে আপনি বর্তমান ম্যাচের ইতিহাসের সময়ে তাঁর সিদ্ধান্ত গ্রহণের মাধ্যমে আপনার যে কৌশলটি পরিবর্তন করতে পারেন তার যে কোনও এবং সমস্ত তথ্য আপনি ব্যবহার করতে পারেন আপনার বিরুদ্ধে কৌশল পরিবর্তন করতে প্রতিপক্ষের। আপনি প্যাটার্ন / হিউরিস্টিকস ইত্যাদি তৈরি করতে আপনার আগের গেমগুলির ইতিহাসও ট্র্যাক করতে পারেন ... (নীচের বিধিগুলি দেখুন)

একটি একক গেমের সময়, অর্কেস্ট্রেশন ইঞ্জিনটি আপনার বটটি চালাবে এবং আপনার বিরোধীরা 100 মিলিসেকেন্ড আলাদা করে বন্টন করবে এবং তারপরে একই ভাষা / রানটাইমে কোনও পিআরএনজি সংঘর্ষ এড়াতে ফলাফলের সাথে তুলনা করবে। (এটি আসলে আমার পরীক্ষার সময় ঘটেছিল)।

বিচার এবং সীমাবদ্ধতা

ডাঃ শেল্ডন কুপার শেলডোরের ছদ্মবেশে বিজয়ী আন্তরিকভাবে টুর্নামেন্টের সঞ্চালনের তদারকি করার প্রস্তাব দিয়েছেন। শেল্ডার দ্য কনকারার একটি সুষ্ঠু ও ন্যায়বিচারক অধ্যক্ষ (বেশিরভাগ)। শেল্ডারের সমস্ত সিদ্ধান্ত চূড়ান্ত are

গেমিংটি সুষ্ঠু ও যথাযথভাবে পরিচালিত হবে:

• আপনার বট স্ক্রিপ্ট / প্রোগ্রাম একটি সাবফোল্ডারের অধীনে অর্কেস্ট্রেশন ইঞ্জিনে সংরক্ষণ করা হবে Players\[YourBotName]\
• আপনি Players\[YourBotName]\dataবর্তমান টুর্নামেন্টের যে কোনও ডেটা বা গেমের ইতিহাস লগ করার জন্য সাবফোল্ডারটি ব্যবহার করতে পারেন । প্রতিটি টুর্নামেন্ট রান শুরু হওয়ার সাথে সাথে ডেটা ডিরেক্টরিগুলি মুছে ফেলা হবে।
• আপনি টুর্নামেন্টে অন্য খেলোয়াড়ের প্লেয়ার ডিরেক্টরি অ্যাক্সেস করতে পারবেন না
• আপনার বটটিতে নির্দিষ্ট কোড থাকতে পারে না যা অন্য নির্দিষ্ট বট আচরণকে লক্ষ্য করে
• প্রতিটি খেলোয়াড় এতক্ষণ খেলতে একাধিক বট জমা দিতে পারে যতক্ষণ না তারা একে অপরকে ইন্টারঅ্যাক্ট করে বা সহায়তা না করে।

সম্পাদনা করুন - অতিরিক্ত সীমাবদ্ধতা

• হারানো সম্পর্কিত বিষয়ে, তাদের সমর্থন করা হবে না। আপনার বটটি অবশ্যই 5 টি বৈধ হাতের মধ্যে একটি খেলতে হবে। আমি টুর্নামেন্টের বাইরের প্রতিটি বটকে কিছু এলোমেলো ডেটা দিয়ে পরীক্ষা করব যাতে তারা আচরণ করে তা নিশ্চিত করে নিন। যে কোনও বট ত্রুটি ফেলে দেয় (যেমন ত্রুটিগুলি হারায়) ততক্ষণে তারা ত্রুটিযুক্ত না করে ট্যুরনি থেকে বাদ দেওয়া হবে।
• বটগুলি এতক্ষণ দীর্ঘমেয়াদী হতে পারে যেহেতু তারা তাদের আচরণে সংক্ষিপ্তভাবে পৃথক। বিদ্যমান বোটের মতো হুবহু একই আচরণ সম্পাদনকারী বটগুলি অযোগ্য ঘোষণা করা হবে
• নিম্নলিখিতগুলির জন্য ইতিমধ্যে স্প্যাম বট রয়েছে তাই দয়া করে পুনরায় জমা দিন না
• • রক - বার্টসিম্পসন
• • কাগজ - লিসাসিম্পসন
• • কাঁচি - এডওয়ার্ডসিসারহ্যান্ডস
• • স্পোক - ভলকান
• • টিকটিকি - খালাসী
• • সিউডো র্যান্ডম - সিম্পলর্যান্ডমবট এবং ফেয়ারবট
• • Psuedo র্যান্ডম আরপিএস - কনজারভেটিভবট
• • Psuedo র্যান্ডম LV - বার্নি স্টিনসন
• বটগুলি তৃতীয় পক্ষের পরিষেবা বা ওয়েব সংস্থানগুলিতে কল করতে পারে না (বা ম্যাচের গতি / সিদ্ধান্ত নেওয়ার সময়কে ধীরে ধীরে ধীরে ধীরে কমিয়ে দেয় এমন কিছু) anything CasinoShakespeareএই সীমাবদ্ধতা যুক্ত হওয়ার আগে যে বট জমা দেওয়া হয়েছিল কেবলমাত্র ব্যতিক্রম।

শেল্ডার টুর্নামেন্টের ফলাফলগুলির সাথে যত তাড়াতাড়ি সম্ভব এই প্রশ্নটি আপডেট করবেন, যত বেশি বট জমা দেওয়া হয়।

অর্কেস্ট্রেশন / নিয়ন্ত্রণ প্রোগ্রাম

অর্কেস্ট্রেশন প্রোগ্রাম এবং প্রতিটি বটের সোর্স কোড সহ গিথুব উপলভ্য।

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

জমা দেওয়ার বিবরণ

আপনার জমা অন্তর্ভুক্ত করা উচিত

• আপনার বট এর নাম
• তোমার গোপন সংকেত
• একটি আদেশ
  • শেল যেমন আপনার বট এক্সিকিউট
  • রুবি myBot.rb
  • পাইথন 3 মাইবট.পি
  • অথবা
  • প্রথমে আপনার উভয়টি সংকলন করুন এবং তারপরে এটি সম্পাদন করুন। যেমন
  • 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 কার্যকরভাবে নিজেকে পরাজিত করার চেষ্টা করছে। (আমি কিছুটা সন্দেহজনক হয়ে উঠলাম কারণ আমার বট প্রতিটি ম্যাচ জিতেছিল যেখানে এটি খেলোয়াড় ছিল অন্য ম্যাচের অর্ধেক হারাতে।)

— এমিল

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 শতাংশ জয়ের অনুপাত অসামান্য।

— অ্যান্ডোডান

খুব সুন্দর. আপনি ইওকেন পাউডার পছন্দ করতে পারেন , যদি আপনি এটি ইতিমধ্যে না দেখে থাকেন।

— wchargin

@WChargin অবশ্যই। :) আমি যখন আমার আসল কোডটি লিখেছিলাম তখন আমি কয়েক বছর আগে আইওকেইন পাউডারটি পড়েছিলাম এবং অস্পষ্টভাবে সাধারণ ধারণাটি মনে রেখেছিলাম। সুতরাং, পনি প্রকৃতপক্ষে এটি থেকে অনুপ্রাণিত, খুব সরাসরি না হলে। দেখা যাচ্ছে যে এগুলি খুব একই রকম। আমি মনে করি খনিতে কৌশলগুলির একটি বৃহত্তর পুস্তক রয়েছে যখন আইওকেইন পাউডারের মেটা-মেটা যুক্তিগুলির একটি চতুর স্তর রয়েছে যা আমি অন্তর্ভুক্ত করি নি।

— এমিল

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

এবং তারপরে আমি এই প্রোগ্রামটি ব্যবহার করে সর্বাধিক সম্ভাব্য পদক্ষেপটি নির্ধারণ করতে ব্যবহার করব যা আমি এরপরে করব এবং তারপর আপনি কী করবেন তা খুঁজে বার করুন এবং অবশেষে আপনি কী করবেন তা মারার উপায় খুঁজে বার করুন এবং বার বার পুরো জিনিসটিকে অসীম-লুপ করুন।

— জেমি

@ জামি তুমি কি এই লোকটির মত? কোডগল্ফ.স্ট্যাকেক্সেঞ্জাওয়েটা

— মার্টিন

আপনি এটি অনুমান। (মন্তব্য পোস্ট করার জন্য যথেষ্ট দীর্ঘ ছিল না)

— জেমি

Answer 3

কনজারভেটিভবট, রুবি

নতুন জিনিস খারাপ জিনিস।

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

মত দৌড়াও

ruby conservative.rb

Comments

ওজি সংস্করণটি সেরা সংস্করণ।

— ম্যাক্সিউব

Answer 4

স্টার ওয়ার্স ফ্যান - রুবি

আপনি স্ক্রু, স্পক

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

এটি চালান:

ruby starwarsfan.rb

Comments

কন্ট্রোলারে যুক্ত হয়েছে

— ইয়োন ক্যাম্পবেল

আপনি উত্তর সম্পাদনা করে রোলব্যাক করতে পারেন - আমি যখন এগুলি যুক্ত করব তখনই আমি এখানে মন্তব্য করব।

— ইয়ন ক্যাম্পবেল

আর আর এস কেন? : পি

— সিজেফুরে

@mardavi এটি স্টার ওয়ার্সের অনুরাগী কারণ এটি স্পক ব্যবহার করে না।

— উইলিয়াম বারবোসা

আহ, আপনি ঠিক বলেছেন (অবশ্যই) আমি এটি খুব দ্রুত পড়েছি, আমার ভুল (তবে ভাগ্যক্রমে পরিণতি ছাড়াই)

— মারদাভি

Answer 5

বার্নি স্টিনসন - লুয়া

আমার কেবল একটি নিয়ম রয়েছে: নতুন সর্বদা ভাল। পুরানো জো কেন পো বা আপনি যেটাকেই কল করুন Sc

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

মনে রাখবেন যে এটি যদি এমন কৌশল হয় যা ইতিমধ্যে অন্য কেউ ব্যবহার করছে তবে আমাকে জানতে দিন এবং আমি মুছে ফেলব। এটি কেবল স্পষ্ট মত মনে হচ্ছে যা আমি ইতিমধ্যে দেখিনি।

— কেইন

এই সি # হয়? আপনি। দৈর্ঘ্যের বৈশিষ্ট্যগুলি ভুল। এবং কোনও পদ্ধতি নেইmax

— অয়ন ক্যাম্পবেল

@ ইইনক্যাম্পবেল এটি জাভা, আমি উভয়ের সাথেই খেলছি এবং স্পষ্টতই ভুলে গেছি কোনটি আদেশের অন্তর্ভুক্ত।

— কেইন

আহ আহ। এটি আমার সাথে ছেড়ে দিন এবং আমি এটি অন্তর্ভুক্ত করব।

— ইয়ন ক্যাম্পবেল

এখনও ভাঙ্গা। চলমান jre8 - জাভা BoringBot.java - ত্রুটি: মূল শ্রেণি ডি খুঁজে পাওয়া বা লোড করা যায়নি: \ আমার সফ্টওয়্যার দেব \ বিগ-ব্যাং-গেম \ বিগব্যাং.আরকেস্ট্রেটর \ বিন \ ডিবাগ \ খেলোয়াড় \ বোরিংবোট \ বোরিংবোট.জাভা -

— ইওন ক্যাম্পবেল

Answer 7

আইওকেইন পাউডার, রুবি

এখানে আরপিএস কৌশল ভিত্তিক অফ (নির্লজ্জভাবে চুরি করা) । বট দেখতে মারকোভ বটের অনুরূপ অনুমান চয়ন করে তবে তারপরে ধরে নেওয়া হয় যে প্রতিপক্ষ তার পছন্দনীয় ফলাফলটি অনুমান করেছে এবং সেই অনুযায়ী সেটিকে পরাস্ত করার জন্য বেছে নিয়েছে।

মনে রাখবেন যে আমি লিঙ্কযুক্ত কৌশলটির মূল ধারণাটি সবেমাত্র গ্রহণ করেছি, এটিকে বিশদভাবে অনুসরণ করি নি।

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

আপনি এই শব্দটি ব্যবহার করতে থাকুন। আপনি মনে করেন না এটির অর্থ কী means

— জোশডিএম

আইওকেইন পাউডারের আসল শক্তি হ'ল এটি ছিল মার্কভ ব্যবহার এবং মারধর-মার্কভের মধ্যে স্যুইচ। এটি স্মার্ট মার্কভ হিসাবে শুরু হয়, তবে একবার যখন এটি অনুভূত হয় (হারাতে শুরু করে) এটি মারধর-মার্কভ মোডে ঝাঁপিয়ে পড়ে। যোগ করা সহজ হতে হবে।

— রায় ভ্যান রিজন

আহ, চালাক! মিথ্যা বলা হবে না, আমি কেবল শুনেছি আইওকিন আমাকে বর্ণনা করেছেন, আসলে এটিকে বিস্তারিতভাবে দেখেননি। আপনি নিজের কোডটি জমা দিতে বা জমা দিতে এবং ক্রেডিট পেতে চাইলে আমার কোডটি সংশোধন করুন

— jmite

Answer 8

হডল ওল্ফ দ্য কনকরার - সি #

হডল ওল্ফ আগের চেয়ে ভাল এবং ফিরে এসেছে। তিনি নিজের বোকা খেলায় শেল্ডারকে বিজয়ী করবেন। হডলওল্ফ স্প্যামারবটগুলি সনাক্ত এবং পাল্টানোর জন্য যথেষ্ট স্মার্ট। আরও বুদ্ধিমান প্রতিপক্ষের জন্য, হাডল ওল্ফ তার 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

আমাদের কি প্রিন্ট বা প্রিন্টলন ব্যবহার করা উচিত? ... আমি নিশ্চিত ছিলাম না।

— কেইন

হুম। আমি ভাবতে পারি যে দুজনেই কাজ করবে, তবে কন্ট্রোল প্রোগ্রামটি চরিত্রটির পরিবর্তে নতুন লাইন ধরলে আমি প্রিন্টলন গোলযোগ দেখতে পেলাম। এটি উল্লেখ করার জন্য ধন্যবাদ, আমি আমার কোডটি সম্পাদনা করব ঠিক সে ক্ষেত্রে

— স্ট্রানজায়ার

@ স্ট্রাঞ্জির আপনার শেষ দৌড়ে কিছু বাগ রয়েছে। এটি কন্ট্রোল প্রোগ্রামটিতে বোমা ফেলেনি তবে আপনি "টডলারপ্রুফ প্লে এন" এর জন্য ইতিহাস অনুসন্ধান করলে মনে হয় আপনার বটটি কিছু হাতের জন্য নাল ফিরছে এবং তারপরে হাতটি অটোলেস করছে। উদাহরণ গেমটি হ'ল "ইকো এবং টডললারপ্রুফ" যেখানে আপনার বোট ক্রপ করা শুরু হওয়ার আগে ইকো "এলভিএসপিআরএলভি" খেলেছিল।

— ইইন ক্যাম্পবেল

@ আইওন ক্যাম্পবেল এটি উল্লেখ করার জন্য ধন্যবাদ। আমি দেখেছি এর আগে যখন আপনি ব্যর্থ ট্যুরনি থেকে লগগুলি পোস্ট করেছিলেন এবং আমি মনে করি এটি ঠিক করে ফেলেছি। এটি একটি ত্রুটির দিকে চলেছিল যেখানে এটি যদি এলোমেলো খেলায় লাফিয়ে না গিয়ে সরাসরি 5 টিরও বেশি হারায় তবে এটি একটি অবৈধ মান ফেলেছে। এবং তারপরে, এটি এটি হারাতে তৈরি করার কারণে এটি অন্য একটি অবৈধ মান ছুঁড়েছে । একটি পঙ্কিল চক্র.

— Stranjyr

কুল। এটি এখন নিয়ন্ত্রণ অগ্রগতি আপডেট করুন।

— ইয়োন ক্যাম্পবেল

Answer 10

বার্ট সিম্পসন

"ভাল পুরানো শিলা! কিছুই রক দেয় না!"

puts 'R'

হিসাবে চালান

ruby DoTheBartman.rb

---

লিসা সিম্পসন

"দরিদ্র, অনুমানযোগ্য বার্ট। সর্বদা শিলা পছন্দ করে।"

puts 'P'

হিসাবে চালান

ruby LisaSimpson.rb

---

বেটার লিসা সিম্পসন

লিসাকে এত বোকা বানানো নিয়ে আমার খারাপ লাগছিল, তাই আমি তাকে এলোমেলোভাবে দুটি হাতের মধ্যেই বেছে নিতে দিয়েছি যা শিলাকে পরাস্ত করবে। তবুও বোকা, তবে সে সর্বোপরি সিম্পসন। হয়ত কোনও ক্রাইওন তার মস্তিস্কে আটকে গেল?

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

হিসাবে চালান

ruby BetterLisaSimpson.rb

Comments

অপ্রাপ্তবয়স্ক সংঘর্ষ । যাইহোক +1।

— মার্টিন ইন্ডার

@ মার্টিনবাটনার ড্যাম, এটি লক্ষ্য করেনি। প্রোগ্রামগুলি যদিও এখনও বিভিন্ন কাজ করে বলে মনে হচ্ছে - এবং কমপক্ষে এখানে লিসা তার ভাইয়ের দুটি ভিন্ন সংস্করণকে পেটানোর মাধ্যমে আরও বেশি বোধ করতে পারে।

— ডাঃ আর ডিজল

শেল্ডার সম্মত ... একটি বার্টবট এবং একটি বার্টসিম্পসন থাকবে :)

— ইয়োন ক্যাম্পবেল

আমাদের কেবল বোর্টবট আছে।

— জোশডিএম

এই মার্কভ :) দ্বারা জবাই করা হবে

— Cruncher

Answer 11

প্রতিধ্বনি

সি # তে লেখা। সঙ্গে সংকলন 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 !!!

— ইয়ন ক্যাম্পবেল

তবে বিগ ব্যাংয়ের প্রত্যেকে কীভাবে এভাবে খেলেন?

— কেইন

@ ননথরগুয়েস্ট এটাই বলতে চেয়েছি "এটিই কেবলমাত্র চরিত্রের কৌশল"।

— মার্টিন এন্ডার

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

বেয়েসিয়ানবট, পার্ল (এখন ভি 2!)

অন্য কিছুর উপরে, এটি একটি অনন্য প্রোগ্রাম। এটিতে, আপনি পরিসংখ্যান এবং ভয়ঙ্কর প্রোগ্রামিং ফর্মের উজ্জ্বল ফিউশন দেখতে পাবেন। এছাড়াও, এই বটটি সম্ভবত বয়েশিয়ান পরিসংখ্যানের অনেকগুলি নিয়ম ভঙ্গ করে তবে নামটি আরও শীতল লাগে।

এই বটটির মূল সারমর্মটি এটি 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))])

ভাষা: পাইথন ৩.৪.১

আদেশ: python dynamicbot.py <history>বা python3 dynamicbot.py <history>আপনার সিস্টেমের উপর নির্ভর করে

Comments

হ্যাঁ, এটা সম্পর্কে চিন্তা।

— seequ

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

আমি বিশ্বাস করি আপনি যদি এটি প্রথমে ঝাঁকিয়ে পড়ে থাকেন তবে আপনি কীভাবে এটি চালাবেন I আপনি যদি প্রথমে এটি সহজভাবে সংকলন করেন তবে java ABotকাজ করা উচিত (ফাইলটির নাম পাবলিক ক্লাসের মতো মনে রাখবেন)

— জাস্টিন

ধন্যবাদ! তুলনামূলকভাবে নতুন প্রোগ্রামার হিসাবে আমি এ সম্পর্কে সচেতন ছিলাম না।

— স্ট্রেচ পাগল

Answer 17

SpockOrRock - পিএইচপি

বাস্তব বিশ্বে খেলে বেশিরভাগ লোক সহজাতভাবে কাঁচি বাছাই করে। এই বট গড় প্লেয়ারকে পরাস্ত করতে স্পোক বা রককে বেছে নেয়। এটি আগের রাউন্ডগুলি নিয়ে মাথা ঘামায় না।

সাথে চালানো 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

@ মার্টিনব্যাটনার: কমান্ড যুক্ত! আমি কিছু প্রকাশিত হওয়ার চেষ্টা করে কাজটিতে বেশ ব্যস্ত ছিলাম, তাই নিখোঁজ।

— কাইল কানোজ

কোনও রান ছাড়াই প্রথম রান করতে বিরতি। ট্রেসব্যাক (সর্বশেষতম কল শেষ): "মডেলোগুলি প্রতিপক্ষ = sys.argv [2] ইনডেক্সেরর: তালিকা সূচকের বাইরে তালিকা

— ইওন ক্যাম্পবেল

@ ইইন ক্যাম্পবেল: আমি প্রথম রান করার প্রস্থানের বিধিটি ভুলে গেছি, এটি যুক্ত হয়েছে এবং এখনই ঠিকঠাক কাজ করা উচিত।

— কাইল কানোজ

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

জাভা - সেলফলথিংবোট

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

বট এলোমেলোভাবে শুরু হয়, তারপরে এলোমেলোভাবে যেতে, 33%, বা তাত্ক্ষণিক পূর্বের নাটকগুলির বিরুদ্ধে 50% পছন্দসই কৌশল অবলম্বন করে বিজয়ী কৌশল খেলতে ~ 33%।

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 টি চাল খুঁজে পেয়েছে এবং ধরে নিয়েছে যে এবার প্রতিপক্ষের পদক্ষেপ সেই দু'জনের মধ্যে একটি হবে be একটি জয়ের জন্য 2, একটি ড্র এবং 1 টিতে একটি হারের জন্য 2 নির্ধারিত করে, এটি এই দুটি পূর্বাভাসিত চালকের বিপরীতে সর্বাধিক স্কোরের সাথে সরানো সন্ধান করে এবং এটি নিক্ষেপ করে।

জুয়ার ভাই - পাইথন 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

কোন অবস্থায় থেগমেলার মোডে পরিবর্তন করে?

— ডাঃ আর ডিজল

@ ডিআরআরডিজল এটি নয়, দেখে মনে হচ্ছে এটি একটিতে দুটি বটের জমা।

— পাওলো ইবারম্যান

আপনি যদি পর পর নির্দিষ্ট পরিমাণের চেয়ে বেশি সময় হারান তবে মোডে সুইচিং করা থাকলে এই প্রোগ্রামটি আরও কার্যকর হবে না?

— ডাঃ আর ডিজল

Answer 25

ডায়েনস্ট্যাগ (পাইথন 2)

আমার প্রথম এন্ট্রি পনি মনে হয় এর সমস্ত দ্বিতীয় অনুমান (ট্রিপল অনুমান, ...) এবং মেটা যুক্তি দিয়ে বেশ ভালভাবেই ব্যয় করেছে। তবে এটি কি প্রয়োজনীয়?

সুতরাং, এখানে পোনির ছোট্ট বন্ধু ডায়েনস্ট্যাগ, 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'

• ইতিহাস জোড়াগুলির তালিকায় একত্রিত হয় এবং চালগুলি সংখ্যায় অনুবাদ হয় (আর = 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'

দ্রষ্টব্য: ডায়ানস্টাগের এন রাউন্ডগুলির পরে পরবর্তী পদক্ষেপটি ফিরিয়ে দেওয়ার জন্য সময় জটিলতা ও ( এন ² ) রয়েছে । পনিতে সময় জটিলতা রয়েছে ( এন ³ ) has সুতরাং এই দিকটিতে তারা সম্ভবত আরও খারাপ পরে অন্যান্য এন্ট্রি।

Comments

দয়া করে করুন এটি আমার জন্য দুর্দান্ত একটি শেখার অভিজ্ঞতা। আমি সাধারণত সি # / জাভা জমিতে থাকি তাই সমস্ত লুয়া, রুবি, পাইথন, হাস্কেল পাগলামি আমার কাছে খুব আকর্ষণীয়।

— অয়ন ক্যাম্পবেল

আমি গেমগুলিতে পনির একটি অতিরিক্ত উদাহরণ যুক্ত করার জন্যও প্রলুব্ধ হই। এটি আপনার মিরর নিজের সাথে লড়াই করতে যাওয়ার মতো হবে 3 য় থেকে শেষ মার্টাল কম্ব্যাট লেভেল ;-)

— ইওন ক্যাম্পবেল

@ ইইন ক্যাম্পবেল :-) কমপক্ষে সরাসরি ম্যাচ পনি বনাম পনি একটি নিখুঁত ড্র হবে। আমার উভয় বটগুলিতে এলোমেলোতার কোনও উপাদান নেই।

— এমিল

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। এটির সাথে কিছু সমস্যা হচ্ছে ... আমি সাইগউইন ইনস্টল করেছি এবং সি স্ক্রিপ্টগুলিকে সি: g সাইগউইন \ বিন এর জন্য সম্পূর্ণরূপে যোগ্যতাসম্পন্ন পাথ সহ পরিবর্তন করেছি এবং ..exe, xargs.exe এবং ইকো.এক্স.ই. এখনও নিম্নলিখিত ত্রুটি পেয়েছি। সি: / সাইগউইন / বিন / এক্সার্গস: ইকো: এ জাতীয় কোনও ফাইল বা ডিরেক্টরি% 5 "নয়) সিনট্যাক্স ত্রুটি: অপারেন্ড প্রত্যাশিত (ত্রুটির টোকেন"

— ইওন ক্যাম্পবেল

@ ইইনক্যাম্পবেল - আপনি যখন উইন্ডোতে ফাইলটি তৈরি করেন, তখন আপনি ফাইলটি চালানোর dos2unixআগে সাইগউইনে চালাতে পারেন?

— এমসিএনসিএএনএনএফ

নিশ্চিত করুন। আমি চেষ্টা করে দেব।

— ইয়োন ক্যাম্পবেল 21

আমি মনে করি / ডি / ইউরেন্ডম স্টেটমেন্টটি নিয়ে সমস্যা হতে পারে

— ইয়োন ক্যাম্পবেল

Answer 27

অ্যালগরিদম

একটি থাকার খাতিরে একটি অ্যালগরিদম।

কুউজ এটি সর্বদা নিরাপদে কিছু করতে নিরাপদ বোধ করে, আরও জটিলতর আরও ভাল।

এখনও কিছু গুরুতর ম্যাথ করেনি, তাই এই অ্যালগরিদমটি তেমন কার্যকর হতে পারে না।

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

এই অ্যালগরিদমের সংক্ষিপ্তসার: প্রতিপক্ষ সর্বশেষে কী খেলেছে তা দেখুন এবং তারপরে এলোমেলোভাবে দুটি চালচলন খেলুন যা তারা আবার খেললে প্রতিপক্ষের শেষ পদক্ষেপের বিরুদ্ধে হারাবে। সুতরাং এটি এমন বটগুলির বিরুদ্ধে আরও ভাল যা একইভাবে একনাগাড়ে দু'বার চালায় না।

— ররি ও'কেন

হা হা। আমি সত্যিই জানি না যে আমি সেভাবে এটি তৈরি করেছি কিনা। আমি যদি ভুল না হয়ে থাকি তবে এটি আসলে 5 টি পদক্ষেপের যেকোনটি এলোমেলোভাবে বেছে নেওয়ার কেবল একটি সংশ্লেষযুক্ত উপায়। ;)

— ভেক্টরাইজড

Answer 28

ফেয়ারবট, রুবি

সহজ শুরু করা যাক।

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

মত দৌড়াও

ruby fairbot.rb

Comments

সর্বশেষ 'ভি' পরমের উপর ছোট টাইপ আপনি যদি সম্পূর্ণতার জন্য আপডেট করতে চান তবে এটি মাইসাইডে স্থির করে রেখেছেন

— ইয়ন ক্যাম্পবেল

@ ইইন ক্যাম্পবেল ধন্যবাদ, স্থির!

— মার্টিন এন্ডার

মজার বিষয় হ'ল এটি সমস্ত কৌশলগুলির বিপক্ষে জয়ের ঠিক সমান প্রতিকূলতা রয়েছে।

— ক্রাঙ্কার

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

কোন প্যারাম সঙ্গে বিরতি। ট্রেসব্যাক (সর্বশেষতম কল শেষ): "মডেল> প্রতিপক্ষ = sys.argv [2] ইনডেক্সেরর: তালিকা সূচকের বাইরে

— ইওন ক্যাম্পবেল

পরম সঙ্গে বিরতি। ট্রেসব্যাক (সর্বশেষতম কলটি শেষ): "মডেল> মুদ্রণ (পছন্দ_ডিক্ট [বিরোধী_স্তাদ]) -র" লাইন 12, "ভায়োলেন্টবট \ ভায়োলেন্টবট.পি" ফাইল করুন কী-এরর: 'এস'

— ইওন ক্যাম্পবেল

@ ইইন ক্যাম্পবেল: আমি প্রথম রানের জন্য একটি প্রস্থান ধারা যুক্ত করেছি, আপনার এখনই এটি চালানো উচিত।

— কাইল কানোজ

Answer 30

হাস্কেল - মোনাডবট

আমি জানি না যে জিসিসিকে "কারণের মধ্যে" বিবেচনা করা হয়, তবে আসুন আমরা এটি অনুমান করি। এই বটের কৌশলটি তার প্রতিপক্ষের সর্বাধিক জনপ্রিয় পদক্ষেপের বিরুদ্ধে লড়াই করা।

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'