মোরা, কিং অফ নোবেল গেম


28

পটভূমি

মোরার খেলাটি একটি সাধারণ খেলা। "আসল" সংস্করণে বেশ কয়েকটি প্লেয়ার প্রত্যেকের হাতের মোট যোগফল অনুমান করার সময় এক সাথে তাদের হাতে 0-5 নম্বর ফেলে দেয়। আমি এখানে যে সংস্করণটি ব্যবহার করব তা অপ্রয়োজনীয় কৌশলটির সম্ভাবনা বাড়ানোর জন্য পরিবর্তন করা হয়েছে এবং এটি নীচে বর্ণিত হয়েছে:

  • দু'জন খেলোয়াড় আছেন।
  • রক-পেপার-কাঁচিগুলির মতো প্লেয়াররাও একই সাথে চলাফেরা করে।
  • প্রতিটি পালা, প্রতিটি প্লেয়ার 0-5 নম্বর পছন্দ করে এবং তাদের বিরোধীদের 0-5-এর পছন্দটিও অনুমান করে। এর অর্থ হ'ল প্রতিটি সংখ্যা দুটি আউটপুট। স্পষ্ট করার জন্য, উভয় সংখ্যার আউটপুট 0-5 ব্যাপ্তির মধ্যে থাকা উচিত lusive
  • যদি আপনি আপনার প্রতিপক্ষের পছন্দটি সঠিকভাবে অনুমান করেন তবে আপনার প্রতিপক্ষটি সঠিকভাবে অনুমান করে না, আপনি খালি দুটি সংখ্যার যোগফলের সমান একটি নির্দিষ্ট সংখ্যক পয়েন্ট জিতবেন। উদাহরণস্বরূপ, খেলানো সংখ্যাগুলি যদি 3 এবং 5 হয় তবে একটি সঠিক অনুমান 8 পয়েন্টের হতে হবে।
  • উভয় বা উভয়ই খেলোয়াড় যদি সঠিকভাবে অনুমান করেন তবে কোনও পয়েন্ট দেওয়া হয়নি।
  • 1000 রাউন্ডের পরে সর্বাধিক পয়েন্ট পাওয়া ব্যক্তি সেই খেলায় জয়লাভ করে।

প্রতিযোগিতাটি

টুর্নামেন্টটি একটি রাউন্ড-রবিন স্টাইলে করা হবে এবং প্রতিযোগীর প্রতিটি সম্ভাব্য জুটি তৈরি করে পরিচালিত হবে। প্রতিটি বিজয়ের জন্য, প্রতিযোগী 2 জয়ের পয়েন্ট লাভ করে। প্রতিটি টাই ফলাফল 1 বিজয় পয়েন্ট। কোনও বিজয় পয়েন্ট কোনও ক্ষতির জন্য লাভ হয় না।

স্বজ্ঞাতভাবে, টুর্নামেন্টের বিজয়ী অন্যদের বিরুদ্ধে সর্বাধিক বিজয়ী পয়েন্টের সাথে প্রতিযোগী হবে।


কীভাবে প্রবেশ করবেন

প্রতিযোগিতা করতে বট জমা দেওয়ার দুটি পদ্ধতি থাকবে। প্রথম, এবং অনেক পছন্দসই পদ্ধতি হ'ল নিয়ামক দ্বারা সরবরাহ করা একটি জাভা ইন্টারফেস প্রয়োগ করা। দ্বিতীয় পদ্ধতিটি হ'ল একটি স্বাধীন প্রোগ্রাম লিখতে।

প্রথমে জাভা পদ্ধতিটি কভার করা যাক। আপনার যে ইন্টারফেসটি প্রয়োগ করতে হবে তা হ'ল Playerএবং এটি দুটি পদ্ধতির সংজ্ঞা দেয়: public String getName()আপনার বটকে চিহ্নিত করে এবং ছয়টি স্ট্রিংয়ের অ্যারে হিসাবে public int[] getMove(String[] args)গ্রহণ করে ,। একটি উদাহরণ নিম্নলিখিত:argsmychoices myguesses myscore opponentchoices opponentguesses opponentscore

042 045 0 324 432 6

এর অর্থ এই যে আমি প্রথম রাউন্ডে 0 টি বেছে নিয়ে অনুমান করেছি যে আমার প্রতিপক্ষ 0 টি ফেলতে চলেছে My a 2, যার অর্থ তিনি 2 + 4 = 6 পয়েন্ট অর্জন করেন।

আপনার পদ্ধতিটি যথাক্রমে আপনার পছন্দ এবং অনুমান দুটি পূর্ণসংখ্যার একটি অ্যারে প্রদান করবে। একটি উদাহরণ {4,2}4 টি পছন্দ এবং 2 এর অনুমানের জন্য।

একটি পদ্ধতি হিসাবে লিখিত সম্পূর্ণ জাভা বটের উদাহরণ এখানে example আপনি যদি চান তবে আপনার জমা দেওয়ার getMoveপদ্ধতিতে কী চলছে তা অন্তর্ভুক্ত করতে হবে ।

import java.util.Random;
/**
 * A simple example Morra bot to get you started.
 */
public class ExampleBot implements Player
{
    public String getName()
    {
        return "ExampleBot";
    }

    public int[] getMove(String [] args)
    {
        //easiest way I know to break down to create a move history
        //(just contains their throw history)
        char[] theirThrowsC = args[3].toCharArray();
        int[] theirThrows = new int[theirThrowsC.length];
        for(int i = 0; i < theirThrowsC.length; i++)
        {
            theirThrows[i] = Integer.parseInt(Character.toString(theirThrowsC[i]));
        }

        //get my score
        int myScore = Integer.parseInt(args[2]);

        Random r = new Random();
        int guess = r.nextInt(6);
        if(theirThrows.length > 0)
        {
            guess = theirThrows[theirThrows.length-1];
        }

        //throws a random number, guesses what they threw last
        return new int[] {r.nextInt(6),guess}; 
    }

    public static int otherMethod(int example) //you can write additional static methods
    {
        return 0;
    }
}

একটি স্বতন্ত্র প্রোগ্রাম হিসাবে

আমি বর্তমানে অতিরিক্ত ভাষার আমার সমর্থনে সীমাবদ্ধ। জাভা ছাড়াও আমি পাইথন ৩.৪, পার্ল ৫, বা রুবি ২.১.৫ এ লিখিত প্রোগ্রামগুলি গ্রহণ করতে পারি। যদি এমন কোনও ভাষা থাকে যা বেশ কয়েকটি লোক মনে করে, আমি এটি যুক্ত করার জন্য যথাসাধ্য চেষ্টা করব।

আপনার প্রোগ্রামের ইনপুটটি কমান্ড লাইনে যুক্তি হবে be এটি দেখতে এটি দেখতে পারে:

perl awesomebot.plx 042 045 0 324 432 6

আপনার প্রোগ্রামের আউটপুটটি আপনার অনুমান অনুসারে আপনার পছন্দ হওয়া উচিত এবং প্রত্যেকটি সাদা স্থান অনুসরণ করবে।

এটি চালানোর জন্য সঠিক কমান্ডটি আপনার উত্তরে অন্তর্ভুক্ত করুন। মনে রাখবেন যে আমি উইন্ডোজ 8.1 চালাচ্ছি।


অতিরিক্ত বিধি

সংরক্ষণের অবস্থা এবং সময়সীমা

আপনার প্রোগ্রামটিকে স্থানীয় ডিরেক্টরিতে একটি পাঠ্য ফাইল তৈরি করার অনুমতি দেওয়া হবে, যেখানে আপনি তথ্য সংরক্ষণ করতে পারেন। এই তথ্য পুরো টুর্নামেন্ট জুড়ে রাখা হবে কিন্তু পরে মুছে ফেলা হবে। ফাইলটি এমন একটি নাম দিন যা আমি সনাক্ত করতে পারি।

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

আরও জমা দেওয়ার নিয়ম

  • যতক্ষণ না তারা নিয়ম মেনে চলেন এবং ট্যাগ-টিম না রাখেন ততক্ষণ আপনাকে একাধিক জমা দেওয়ার অনুমতি দেওয়া হবে।
  • প্রতিটি প্রবেশ অবশ্যই অনন্য হতে হবে। আপনি অন্য ভাষায় অন্য বট যুক্তির সঠিক অনুলিপি তৈরি করতে পারবেন না।
  • বটগুলি একে অপরের সাথে যোগাযোগ করতে পারে না (কোনও ধরণের দল তৈরি করতে)।
  • আপনি আপনার বটের অভ্যন্তরে থাকা অন্য বটগুলির যুক্তি ব্যবহার করতে পারবেন না, বলুন, আপনার প্রতিযোগীকে সনাক্ত করুন এবং এর ক্রিয়াকলাপের পূর্বাভাস দিন। আপনি অবশ্যই আপনার প্রতিপক্ষের কৌশল নির্ধারণ করার চেষ্টা করতে পারেন।
  • নিয়ামক, অন্যান্য প্রতিযোগী বা আমার কম্পিউটারের সাথে গোলযোগ করার চেষ্টা করবেন না। বাহ্যিক তথ্য উত্সগুলির সাথে সংযুক্ত হবেন না।

নিয়ামক

নিয়ামকের বর্তমান সংস্করণটি এখানে পাওয়া যায় । এটি জাভা ৮ তে লেখা আছে "টুর্নামেন্ট" ফাইলটি প্রধান নিয়ামক, এতে প্রতিযোগীদের তালিকাও রয়েছে (যদি আপনি নিজের প্রতিযোগিতা হোস্ট করতে চান)।


লিডারবোর্ড

আমি সত্যিই খুব প্রায়ই লিডারবোর্ড আপডেট করতে পারিনি। আমি বরং এই সপ্তাহান্তে ব্যস্ত। "বরং ব্যস্ত" দ্বারা আমি বোঝাতে চাইছি সকাল সাড়ে to টা থেকে সাড়ে ৯ টা পর্যন্ত কোনও কম্পিউটারে অ্যাক্সেস নেই। এখানে 5 রানের পর স্কোর are "ইকো" বটটি কোনও কারণে বাজে রাখা হয়েছিল (আমার ভুল হতে পারে, আমি এখনও তদন্ত করিনি)।

  170 - Quinn and Valor                         
  158 - Historian                               
  142 - DeltaMax                                
  140 - MorraCowbell                            
  132 - Extrapolator                            
  115 - Rainbolt                                
  102 - Popularity                              
  100 - Interpolator                            
   83 - CounterBot                              
   80 - Basilisk                                
   76 - Erratica                                
   65 - Trendy                                  
   63 - Scholar                                 
   62 - RandomGuesser                           
   60 - KingFisher                              
   59 - NullifierBot                            
   55 - EvolvedBot                              
   48 - Confused          

ধার

রেইনবোল্ট এবং পিটার টেলরকে কন্ট্রোলারের সাথে সহায়তার জন্য অনেক ধন্যবাদ।


1
@ মার্টিনব্যাটনার রুবি ২.১.৫ যোগ করা হয়েছে।
PhiNotPi

রাউন্ড রবিন কীভাবে কাজ করে? প্লেয়ার 1 বনাম প্লেয়ার 2 1000 বার, প্লেয়ার 1 বনাম প্লেয়ার 3 1000 বার ইত্যাদি ... বা প্লেয়ার 1 বনাম প্লেয়ার 2 একবার প্লেয়ার 1 বনাম প্লেয়ার 3 একবার ইত্যাদি ...
ভজুরা

@ বাজুরা একটি একক টুর্নামেন্ট প্রতিটি জুটির মধ্যে ১ টি যুদ্ধ নিয়ে গঠিত। একটি যুদ্ধের 1000 টি রাউন্ড রয়েছে, যুদ্ধের শেষের দিকে সর্বোচ্চ স্কোর সহ দুটি জয় পয়েন্ট কে পাবে তা নির্ধারণ করে। বর্তমান স্কোরবোর্ড 40 টি টুর্নামেন্টের পরে মোট বিজয় পয়েন্ট দেখায়।
PhiNotPi

বোর্ড আপডেটে বিলম্বের জন্য দুঃখিত। আমি এই সপ্তাহান্তে অত্যন্ত ব্যস্ত। আজ রাতে এবং আগামীকাল সকালে প্রত্যাশা এবং আপডেট করুন।
PhiNotPi

বাহ, আমি আমার বটটি এত ভাল করবে আশা করি না! এছাড়াও, ফলাফলগুলির প্রথম সেট ... বিজয়ের সংখ্যা দ্বারা সংখ্যাগুলি কী বোঝায়?
mbomb007

উত্তর:


17

মোররা কাওবেল

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

এটি Playerইন্টারফেস প্রয়োগকারী একটি সম্পূর্ণ শ্রেণি । নীচে ব্যাখ্যা।

import java.util.Random;

public class MorraCowbell implements Player {
    private final Random rnd = new Random();

    public String getName() {
        return "MorraCowbell";
    }

    public int[] getMove(String[] args) {
        int[] prior = new int[36];
        for (int i = 0; i < 36; i++) prior[i] = 1;
        // args: myChoices myGuesses myScore opponentChoices opponentGuesses opponentScore
        if (args.length == 6 && args[3].length() == args[4].length()) {
            for (int i = 0; i < args[3].length(); i++) prior[6*(args[3].charAt(i) - '0') + (args[4].charAt(i) - '0')]++;
        }

        int[] weights = new int[6];
        for (int r = 0; r < 6; r++) {
            for (int s = 0; s < 6; s++) {
                for (int t = 0; t < 6; t++) {
                    weights[r] += (r + s) * ((r + s == 5 ? 1 : 0) + (r == t ? -1 : 0)) * prior[s * 6 + t];
                }
            }
        }

        // Find the best window.
        int[][] magic = new int[][] {
            { 7776, 6480, 5400, 4500, 3750, 3125 }, { 3125, 2500, 2000, 1600, 1280, 1024 }, { 1875, 1500, 1200, 960,
            768, 640 }, { 1125, 900, 720, 576, 480, 400 }, { 1620, 1296, 1080, 900, 750, 625 }, { 1296, 1080, 900, 750,
            625, 500 }, { 750, 625, 500, 400, 320, 256 }, { 675, 540, 432, 360, 300, 250 }, { 648, 540, 450, 375, 300,
            250 }, { 375, 300, 250, 200, 160, 128 }, { 375, 300, 240, 200, 160, 128 }, { 450, 375, 300, 240, 192, 160,
            128 }, { 324, 270, 225, 180, 150, 125 }, { 270, 225, 180, 144, 120, 100, 80 }, { 225, 180, 150, 120, 96,
            80 }, { 225, 180, 144, 120, 96, 80 }, { 324, 270, 216, 180, 150, 125, 100, 80, 64 }, { 135, 108, 90, 72, 60,
            50 }, { 135, 108, 90, 75, 60, 50, 40, 32 }, { 108, 90, 75, 60, 48, 40, 32 }, { 54, 45, 36, 30, 25, 20, 16 },
            { 54, 45, 36, 30, 24, 20, 16 }
        };
        long bestN = 0;
        int bestD = 1, bestIdx = -1, bestA[] = null;
        for (int[] A : magic) {
            for (int i = 0; i < A.length - 5; i++) {
                long n = 0;
                int d = 0;
                for (int j = 0; j < 6; j++) {
                    n += weights[j] * A[i + j];
                    d += A[i + j];
                }
                if (n * bestD > bestN * d) {
                    bestN = n;
                    bestD = d;
                    bestIdx = i;
                    bestA = A;
                }
            }
        }

        int r = rnd.nextInt(bestD);
        for (int i = 0; i < 6; i++) {
            r -= bestA[bestIdx + i];
            if (r < 0) return new int[] { i, 5 - i };
        }

        // Just a precaution: this should be unreachable.
        return new int[] { 0, 5 };
    }
}

ব্যাখ্যা

আমি কম আঙুল দিয়ে গেম বিশ্লেষণ করে শুরু করেছি। সরলতম অ তুচ্ছ এক কল করতে পারবেন 0বা 1এবং নিম্নলিখিত প্রতিদান সারণী (মান সারি প্লেয়ারের জন্য প্রতিদান হয়) আছে:

       (0,0) (0,1) (1,0) (1,1)
      +-----------------------
(0,0) |  0     0    -1     0
(0,1) |  0     0     0     1
(1,0) |  1     0     0    -1
(1,1) |  0    -1     1     0

(0,0)কৌশল দ্বারা প্রভাবিত হয় (0,1), তাই আমরা সারণীর কমে যায়

       (0,1) (1,0) (1,1)
      +-----------------
(0,1) |  0     0     1
(1,0) |  0     0    -1
(1,1) | -1     1     0

এখন (1,0)কৌশলটির আধিপত্য রয়েছে (0,1), সুতরাং আমরা আরও টেবিলটি কমিয়ে আনতে পারি

       (0,1) (1,1)
      +-----------
(0,1) |  0     1
(1,1) | -1     0

এবং এখন (1,1)দ্বারা আধিপত্য (0,1), তাই আমরা শেষ পর্যন্ত

       (0,1)
      +-----
(0,1) |  0  

অতএব সর্বদা খেলে যাওয়া (0,1)ন্যাশ ভারসাম্যহীন। তবে কৌতূহলজনক বিষয়টি হ'ল এটি একমাত্র নয়। এটি একটি প্রতিসম শূন্য-সম গেম, সুতরাং প্রত্যাশিত বেতনটি 0, এবং যে কোনও মিশ্র কৌশলই মিশ্রিত হয় (0,1)এবং (1,0)যেখানে (0,1)কমপক্ষে 50% সময় বাছাই করা হয় সেই বেতনটি অর্জন করে। সুতরাং আমাদের কাছে ন্যাশ ভারসাম্যের এক-মাত্রিক স্থান রয়েছে।

এটা ক্ষেত্রে হতে যদিও আমি এটা প্রমাণিত হয়নি, যে মনে হয় n-finger Morra একটি হয়েছে nন্যাশ ভারসাম্য যার মধ্যে মিশ্র কৌশল হয় -dimensional polytope n+1 (pick, guess)যার জন্য জোড়া pick + guess = n

উপরের কোডে থাকা যাদু সংখ্যাগুলি ন্যাশ ভারসাম্য রক্ষাকারী 5-মাত্রিক বহুভুজের 32 টি শিখুনকে এনকোড করে। আমি লিনিয়ার প্রোগ্রামিং ইনস্ট্যান্স স্থাপন করে যা পলিটোপকে প্রতিনিধিত্ব করে এবং তারপরে এলোমেলো উদ্দেশ্যমূলক ফাংশনগুলি ব্যবহার করে তাদের পেয়েছি। একটি 32 বাছাইয়ের পরিবর্তে সমস্ত 32 টি এনকোড করার কারণটি সহজ: প্রত্যাশিত বেতনটি 0, সুতরাং জয়ের প্রত্যাশার চেয়ে আমার আরও ভাল করা দরকার। আমি মূলত ধরে নিয়েছি যে অন্য প্লেয়ার একটি মিশ্র কৌশল ব্যবহার করছে এবং তাদের বাছাইয়ের ইতিহাসের ভিত্তিতে বিতরণটি অনুমান করে। তারপরে আমি পলিটোপ ভার্টেক্স নির্বাচন করি যা অনুমান করা বিতরণের বিরুদ্ধে আমার প্রত্যাশিত লাভকে সর্বাধিক করে তোলে।

কুইনঅ্যান্ডভালর এই অনুমানের দুর্বলতা দেখায় যে অন্য খেলোয়াড় একটি মিশ্র কৌশল ব্যবহার করছেন। এমন খেলোয়াড়কে সনাক্ত করে যা ন্যাশ ভারসাম্য থেকে কৌশলগুলি ব্যবহার করে এটি একটি এলোমেলো হাঁটা মোডে স্যুইচ করতে সক্ষম হয় যেখানে একটি ভারসাম্যহীন কৌশল খেলে এটি হারতে গড়পড়তাভাবে দায়বদ্ধ হয়, তবে কেবল একবারে নেতৃত্ব অর্জন করা প্রয়োজন এটি এর জন্য জোড়া খেলতে ফিরতে পারে pick + guess = n। সুতরাং একক গেমের জন্য ন্যাশ ভারসাম্য পুনরাবৃত্ত গেমের জন্য ন্যাশ ভারসাম্যকে তুচ্ছভাবে সাধারণীকরণ করবেন না, যা আরও জটিল কৌশলগুলি মঞ্জুর করে।


4
আপনার যাদুতে হামিং নম্বরগুলির একটি অংশ রয়েছে তা কি সম্ভব ? এটি অবশ্যই তাদের সবগুলি ধারণ করে না, তবে তাদের মধ্যে অনেকগুলি ( বা সমস্ত? ) সেই ওয়েবসাইটে তালিকায় রয়েছে।
জায়ান্ট্রি ট্রি

@ জায়ান্ট্রি, তারা সমস্ত হামিং নম্বর। আকর্ষণীয় পর্যবেক্ষণ।
পিটার টেলর

আপনার বট হ্যাম যাচ্ছে অবাক। : ডি
mbomb007

11

কুইন এবং বীরত্ব (আপডেট)

কুইন এবং বেলোর একটি অভিজাত রেঞ্জার দল। ক্রসবো এবং নখ দিয়ে তারা প্রতিপক্ষকে চ্যালেঞ্জ জানাতে সাহস করে apart

import java.util.ArrayList;
import java.util.List;

interface Champion extends Player {
}

/*
 * Quinn and Valor are an elite ranger team. With crossbow and claw, they ...
 */
public class QuinnAndValor implements Champion {

    private final Champion quinn = new Quinn();
    private final Champion valor = new Valor();

    private int checker;
    private int myScore, opScore;
    private boolean ulted;
    private boolean teemoDetected;
    private boolean quinnNeverLose, valorNeverLose;
    private int quinnScore, valorScore;
    private int quinnRound, valorRound;

    public QuinnAndValor() {
        checker = check() ? 0 : 1;
    }

    // Check if is a fine use
    private static boolean check() {
        return Thread.currentThread().getStackTrace()[3].getClassName().equals(
                "Tournament");
    }

    @Override
    public String getName() {
        return quinn + " and " + valor;
    }

    @Override
    public int[] getMove(String[] args) {
        // Punish for bad usage
        switch (checker) {
        case 1:
            checker++;
            return new int[] { -1, -1 };
        case 2:
            checker++;
            return null;
        case 3:
            throw new Error("Mua he he heh!");
        default:
            if (checker > 0)
                throw new Error("Mua he he heh!");
            break;
        }

        int round = args[0].length();
        if (round == 0) {
            // Buy starting items
            myScore = opScore = 0;
            teemoDetected = false;
            quinnNeverLose = valorNeverLose = true;
            quinnScore = valorScore = quinnRound = valorRound = 0;
            ((Valor) valor).reset();
        }

        if (ulted = useUltimate(args)) {
            valorRound++;
            return valor.getMove(args);
        } else {
            quinnRound++;
            return quinn.getMove(args);
        }
    }

    /*
     * Quinn's ultimate has a lengthy cool-down, especially at lower ranks, so
     * we have to use it only when needed.
     */
    private boolean useUltimate(String[] args) {
        int round = args[0].length();
        int lastMyScore = myScore;
        int lastOpScore = opScore;
        myScore = Integer.parseInt(args[2]);
        opScore = Integer.parseInt(args[5]);
        int score = (myScore - opScore) - (lastMyScore - lastOpScore);
        if (ulted) {
            valorScore += score;
            valorNeverLose &= score >= 0;
        } else {
            quinnScore += score;
            quinnNeverLose &= score >= 0;
        }

        if (round < 100) {
            // Haven't hit level 6 yet
            return false;
        }

        if (myScore > opScore) {
            // We're already winning. Press on with strategy impossible to lose
            if (quinnNeverLose && quinnRound >= 50)
                return false;
            if (valorNeverLose && valorRound >= 50)
                return true;
        } else if (myScore < opScore) {
            // Although Quinn can blind others to counter them, she can be
            // counter be Teemo who also has blind! Don't fall for this!
            if (!teemoDetected) {
                teemoDetected = true;
                for (int i = round - 20; i < round; i++)
                    if (args[3].charAt(i) + args[4].charAt(i) != 'e')
                        teemoDetected = false;
            }
            if (teemoDetected)
                return true;
        }

        if (valorRound < 100) {
            // If we never use our ultimate, how can we know how strong it is?
            return true;
        }

        if (quinnScore < 0 && valorScore < 0)
            return valorRound < quinnRound;
        else
            return quinnScore * valorRound < valorScore * quinnRound;
    }

    @Override
    public String toString() {
        return getName();
    }

    /*
     * Quinn is a female Demacian elite ranger.
     * 
     * @see Valor
     */
    public static class Quinn implements Champion {
        @Override
        public String getName() {
            return "Quinn";
        }

        /*
         * Magic!
         */
        @Override
        public int[] getMove(String[] args) {
            int t = (int) ((Math.sqrt(Math.random() * 168 + 1) - 1) / 2);
            return new int[] { 5 - t, t };
        }

        @Override
        public String toString() {
            return getName();
        }
    }

    /*
     * Valor is Quinn's Demacian eagle.
     * 
     * @see Quinn
     */
    public static class Valor implements Champion {
        @Override
        public String getName() {
            return "Valor";
        }

        private int lastRound;
        private double[][] c;

        public void reset() {
            lastRound = 0;
            c = new double[6][6];
        }

        /*
         * Magic!
         */
        @Override
        public int[] getMove(String[] args) {
            int round = args[0].length();
            int[] b = new int[6];
            for (int i = round - 12; i < round; i++)
                b[args[0].charAt(i) - '0']++;
            {
                double deWeight = Math.pow(0.95, round - lastRound);
                for (int i = 0; i < 6; i++)
                    for (int j = 0; j < 6; j++)
                        c[i][j] *= deWeight;
                double weight = 1;
                for (int i = round - 1; i >= lastRound; i--) {
                    c[args[3].charAt(i) - '0'][args[4].charAt(i) - '0'] += weight;
                    weight *= 0.95;
                }
            }
            lastRound = round;

            List<int[]> pq = new ArrayList<>(1);
            double e = Integer.MIN_VALUE;
            for (int i = 0; i < 6; i++)
                for (int j = 0; j < 6; j++) {
                    double f = 0;
                    for (int k = 0; k < 6; k++)
                        f += (i + j) * c[j][k];
                    for (int k = 0; k < 6; k++)
                        f -= (i + k) * c[k][i];
                    // recently played moves are dangerous
                    f -= b[i] * b[i] * ((round + 11) / 12);
                    if (f >= e) {
                        if (f > e) {
                            pq.clear();
                            e = f;
                        }
                        pq.add(new int[] { i, j });
                    }
                }
            return pq.get((int) (Math.random() * pq.size()));
        }

        @Override
        public String toString() {
            return getName();
        }
    }
}

তারা প্রায় সবসময় আমার মেশিনে সমস্ত জাভা সমাধানের বিরুদ্ধে জয়লাভ করে।

সম্পাদনা:

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

আমার নীতিটি হ'ল যে কোনও সমাধানের জন্য choice + guess == 5, choice + guess == 5আপনার সুবিধার্থে গ্রান্টির সাথে খেলুন।

হালনাগাদ:

ঠিক আছে ... সবকিছু ঠিক জটিল হয়ে গেছে।


1
আমি লীগ অফ লেজেন্ডস রেফারেন্স পছন্দ করি। আমি এখনই একটি টিমো বট বানাতে চাই। :)
mbomb007

6

পণ্ডিত

পণ্ডিত তার প্রতিপক্ষের চালগুলি থেকে শেখার চেষ্টা করেন, তার প্রতিপক্ষটিকে কম অনুমান করা পছন্দ করে এবং তার প্রতিদ্বন্দ্বী সবচেয়ে বেশি ব্যবহৃত অনুমান করেন। তবে তত্ত্বটি সব কিছু নয়, তাই স্কলার খুব ভাল করে না ...

import java.util.HashMap;

public class Scholar implements Player
{
    public static int[] pm = new int[6];
    public static int[] pg = new int[6];
    public static HashMap<Integer, Integer> lm = new HashMap<>();
    public static HashMap<Integer, Integer> lg = new HashMap<>();

    public String getName()
    {
        return "Scholar";
    }

    public int[] getMove(String[] a)
    {
        int r = a[0].length();
        for (int i = 0; i < 6; i++) { pm[i]=0; pg[i]=0; }
        for (int i = 0; i < a[3].length(); i++) {
            int m = Integer.parseInt(String.valueOf(a[4].charAt(i)));
            int g = Integer.parseInt(String.valueOf(a[3].charAt(i)));
            pm[m]++; pg[g]++;
        }
        for (int i = 0; i < pm.length; i++) { lm.put(i, pm[i]); lg.put(i, pg[i]); }

        if (r < 1) {
            return new int[] { 3, 3 };
        } else {

            int mm = lm.entrySet().stream().min((x, y) -> x.getValue() > y.getValue() ? 1 : -1).get().getKey();
            int mg = lg.entrySet().stream().max((x, y) -> x.getValue() > y.getValue() ? 1 : -1).get().getKey();
            return new int[] { mm, mg };
        }   
    }
}

6

DeltaMax

(ফাইলগুলি ব্যবহার না করার জন্য আপডেট হয়েছে এবং একটি নতুন বিভাগ যুক্ত করা হয়েছে Also এছাড়াও প্রথম বিভাগে টাই বাঁধা আটকে না থেকে পরিবর্তিত।)

কয়েকটি কৌশল অবলম্বন করে যা সাধারণ শুরু হয় তবে আরও জটিল হয় - আপনি যদি একটিটি সাফ করেন, এটি আপনাকে পরবর্তী বিভাগে নিয়ে যায় moves

  • বিভাগ 1:{0, 5} ধারাবাহিকভাবে অনুমান
  • বিভাগ 2: আপনার শেষ 4 অনুমানগুলি একটি ধ্রুবক, রৈখিক বা চতুর্ভুজীয় প্যাটার্ন গঠন করে কিনা তা পরীক্ষা করে নিন এবং প্যাটার্নটি ব্রেক না হওয়া অবধি অনুমান করতে থাকুন
  • বিভাগ 3: আপনি কিছু সংখ্যার অস্বাভাবিক কম পরিমাণ (1/13 এর চেয়ে কম) অনুমান করছেন কিনা তা পরীক্ষা করে দেখুন এবং সেই নম্বরটি চয়ন করেন
  • বিভাগ 4: আপনার পছন্দগুলিতে বিগ্রামগুলি বিশ্লেষণ করুন এবং আরও কী কী সম্ভাবনা রয়েছে তা দেখুন
  • বিভাগ 5: অতীত 100 টি রাউন্ডটি দেখুন এবং (choice, guess)সবচেয়ে ভাল প্রত্যাশা থাকবে এমন জোড়টিকে বেছে নিন, ভারিত করুন যাতে সাম্প্রতিক রাউন্ডগুলি আরও গুরুত্বপূর্ণ হয়
  • বিভাগের চূড়ান্ত: কম পছন্দ এবং উচ্চ অনুমানের উচ্চ সম্ভাবনা সহ এলোমেলোভাবে অনুমান করুন। আপনি যদি এখানে পৌঁছে যান, তবে ডেল্ট্যাক্যাক্স ছেড়ে দিয়েছে এবং বলতে চাই, "ভাল খেলা"।

শেষ পর্যন্ত কোন স্ট্র্যাট ব্যবহার করা হয়েছিল তা নির্ধারণের জন্য

if (myChoices.length == 999) { System.out.println(strat); }

লাইন।

ভয়াবহ জাভার জন্য ক্ষমা, আমি আমার বিকেলের পাইকিং বিটগুলি একসাথে এবং ভাষাটি পুনরায় প্রকাশ করতে কাটিয়েছি :)

import java.io.*;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class DeltaMax implements Player
{
    private int strat = 100;

    public String getName() { return "DeltaMax"; }

    public int[] toInts(String s) {
        char [] chars = s.toCharArray();
        int[] ints = new int[chars.length];

        for (int i = 0; i < chars.length; i++){
            ints[i] = Integer.parseInt(Character.toString(chars[i]));
        }

        return ints;
    }

    public int mod6(int n) {
        n = n % 6;
        if (n < 0) { n += 6; }
        return n;
    }

    public int[] getMove(String [] args)
    {
       int[] myChoices = toInts(args[0]);
       int[] myGuesses = toInts(args[1]);
       int myScore = Integer.parseInt(args[2]);
       int[] opponentChoices = toInts(args[3]);
       int[] opponentGuesses = toInts(args[4]);
       int opponentScore = Integer.parseInt(args[5]);

       int rounds = myChoices.length;

       if (rounds == 0) { strat = 100; }
       Random r = new Random();

       // if (myChoices.length == 999) { System.out.println(strat); }

       if (strat == 100) { // Section 1 - {0, 5}
           if (opponentScore - myScore > 21 || (opponentScore >= myScore && rounds > 100)) {
               strat = 200;
           } else {
               return new int[] {0, 5};
           }
       }

       if (strat == 200) { // Section 2 - Mini interpolator
           int w = opponentChoices[opponentChoices.length - 4];
           int x = opponentChoices[opponentChoices.length - 3];
           int y = opponentChoices[opponentChoices.length - 2];
           int z = opponentChoices[opponentChoices.length - 1];

           if (w == x && x == y && y == z) { // Constant
               return new int[] { r.nextInt(4) + 2, w };
           }

           if (mod6(x-w) == mod6(y-x) && mod6(y-x) == mod6(z-y)) { // Linear
               return new int[] { r.nextInt(4) + 2, mod6(z + (z-y)) };
           }

           if (mod6((y-x) - (x-w)) == mod6((z-y) - (y-x))) { // Quadratic
               return new int[] { r.nextInt(4) + 2, mod6((z-y) + mod6((y-x) - (x-w))) };
           }

           strat = 300;
       }

       if (strat == 300) { // Section 3 - exploit least guessed
           int [] counts = new int[6];

           for (int i = 0; i < rounds; i++) {
               counts[opponentGuesses[i]] += 1;
           }

           int minCount = rounds;

           for (int i = 0; i < 6; i++) {
               if ((counts[i] <= 1 || counts[i] * 13 < rounds) && counts[i] < minCount) {
                   minCount = counts[i];
               }
           }

           if (minCount == rounds) {
               strat = 400;
           } else {
               ArrayList<Integer> choices = new ArrayList<Integer>();

               for (int i = 0; i < 6; i++) {
                   if (counts[i] == minCount) {
                       choices.add((Integer) i);
                   }
               }

               int choice = choices.get(r.nextInt(choices.size()));

               // {0, 0} is about the worst thing you can do, so DeltaMax tries to avoid that
               if (choice == 0) {
                   return new int[] { 0, r.nextInt(4) + 2 };
               } else {
                   return new int[] { choice, r.nextInt(6) };
               }
           }
       }

       if (strat == 400) { // Section 4 - bigrams
           if (opponentScore - myScore > 42 || (opponentScore >= myScore && rounds > 300)){
               strat = 500;
           } else {
               int[] opponentScores = new int[6];
               int opponentLast = opponentChoices[opponentChoices.length - 1];

               int[] myScores = new int[6];
               int myLast = myChoices[myChoices.length - 1];

               for (int i = 0; i < opponentChoices.length - 1; i++) {
                   if (opponentChoices[i] == opponentLast) {
                       opponentScores[opponentChoices[i+1]] += 1;
                   }

                   if (myChoices[i] == myLast) {
                       myScores[myChoices[i+1]] += 1;
                   }
               }

               int maxIndex = -1;
               int maxScore = 0;

               int minIndex = -1;
               int minScore = rounds;

               for (int i = 0; i < 6; i++) {
                   if (opponentScores[i] >= maxScore) {
                       maxScore = opponentScores[i];
                       maxIndex = i;
                   }

                   if (myScores[i] <= minScore) {
                       minScore = myScores[i];
                       minIndex = i;
                   }
               }

               if (minIndex == 0 && maxIndex == 0) {
                   return new int[] { 0, r.nextInt(4) + 2 };
               } else {
                   return new int[] { minIndex, maxIndex };
               }
           }
       }

       if (strat == 500) { // Section 5 - best expectation
           if (opponentScore - myScore > 84 || (opponentScore >= myScore && rounds > 800)){
               strat = 573;
           } else {
               int minLen = Math.min(rounds, 100);

               double bestScore = 0;
               int bestGuess = 0;
               int bestChoice = 5;

               for (int guess = 0; guess < 6; guess++) {
                   for (int choice = 0; choice < 6; choice++) {
                       double score = 0;
                       int start = rounds - minLen;

                       for (int i = start; i < rounds; i++) {
                           if (opponentGuesses[i] == choice && opponentChoices[i] != guess) {
                               score -= (choice + opponentChoices[i]) * ((double) i - start) / minLen;
                           } else if (opponentGuesses[i] != choice && opponentChoices[i] == guess) {
                               score += (choice + opponentChoices[i]) * ((double) i - start) / minLen;
                           }
                       }

                       if (score > bestScore) {
                           bestScore = score;
                           bestGuess = guess;
                           bestChoice = choice;
                       }
                   }
               }

               if (bestChoice == 0 && bestGuess == 0) {
                   return new int[] { r.nextInt(4) + 2, bestGuess };
               } else {
                   return new int[] {bestChoice, bestGuess};
               }
           }
       }

       // Section final - hope for the best
       int num = (int) Math.floor(Math.sqrt(r.nextInt(35)));
       return new int[] {5 - num, num};
    }
}

কন্ট্রোলারের বর্তমান প্রয়োগের সাথে, যদি ডেটা কেবলমাত্র একটি গেমের জন্য ব্যবহার করা হয় তবে কোনও ফাইলে জিনিস সংরক্ষণ করার দরকার নেই। অর্থাত্ private int strat;যথেষ্ট ভাল।
johnchen902

@ jhnchen902 ধন্যবাদ, আমি বুঝতে পারি না যে আমি এটি করতে পারি। এটি বিষয়গুলি অনেক সহজ করে তোলে।
Sp3000

6

ইতিহাসবেত্তা

(আপডেট: একই যুক্তি, সংক্ষিপ্ত কোড এবং 100 গুণ দ্রুত তবে আপনি একটি টুর্নামেন্টে কেবলমাত্র একটি Histতিহাসিক বট ব্যবহার করতে পারেন))

পূর্ববর্তী ইতিহাসের বিরোধীদের বিরুদ্ধে কেবল সেই জুটিটি ব্যবহারের কার্যকারিতার ভিত্তিতে একটি থ্রো-অনুমানের জুড়ি চয়ন করতে ওজনযুক্ত এলোমেলো ব্যবহার করে। ওজন হ'ল অর্জনযোগ্য স্কোরগুলির স্কোয়ার।

public class Historian implements Player {
    private static java.util.Random r = new java.util.Random();
    private static int[] sc=new int[36]; //reseted between games, use only one Historian bot
    public String getName() {return "Historian";}
    public int[] getMove(String [] a) {
        if (a[3].length()==0)  {sc=new int[36]; for(int i=0;i<6;i++) sc[i*6+(5-i)]=5-i;}
        else {int t=a[3].charAt(a[3].length()-1)-'0'; int g=a[4].charAt(a[3].length()-1)-'0';
            for(int i=0; i<6; i++) {sc[i*6+t]+=i+t; sc[g*6+i]-=t+g;}}
        int sum=0; for(int i=0; i<36; i++) {sum+=(sc[i]<1)?1:sc[i]*sc[i];}
        int seed=r.nextInt(sum);int mt=-1;
        while (seed>=0) {seed-=(sc[++mt]<1)?1:sc[mt]*sc[mt];}  
        return new int[] {(int)(mt/6),mt%6};} }

বিটস Quinn and Valor (আর নয়) এবং হেরে যায় Morra Cowbell। টুর্নামেন্টে বেশিরভাগ বট নিয়ে Historianদ্বিতীয় স্থান আসে Quinn and Valor


ভাল, আমি কারও মেশিনে জিতেছি দেখে ভাল লাগছে। আমি বর্তমান অফিসিয়াল লিডার বোর্ডকে হারাচ্ছি । আমি ভাবছিলাম এর দুর্ভাগ্য বা কিছু অপ্রত্যাশিত সূক্ষ্ম বাগের কারণে।
johnchen902

@ johnchen902 আমি অলীক প্রহার থাকতে হবে Morra Cowbell। পোস্ট সম্পাদনা। মন্তব্যগুলি যদি অচল হয়ে যায় তবে আপনি মুছতে পারেন।
এলোমেলো

আমি মনে করি আমি আমার আপডেটের পরে এখন আমাদের দ্বন্দ্বের 75% জিততে পারি!
johnchen902

5

এক্সট্রোপোলটার (v1.1)

একটি সহজ গেমের ন্যাশ-ভারসাম্যগুলির একটির কাছ থেকে চরম এক্সট্রোপোলেশন।

আমি সংক্ষিপ্ত উত্তর বিন্যাস সমর্থন! (পাইথন-স্টাইলে।)

public class Extrapolator implements Player { 
    private static java.util.Random r = new java.util.Random();
    public String getName() { return "Extrapolator"; }
    public int[] getMove(String [] args) {
        int t=-1;
        for(int c=15,s=r.nextInt(60);s>=0;s-=c,c-=2,t++);
        return new int[] {t,5-t}; } }

ম্যাজিক গরু (মোরা কাওবেল) এর সাথে তাল মিলবে এবং আমি যাচাই করেছিলাম এমন অন্যান্য এন্ট্রিগুলিকে মারধর করে।


1
দয়া করে র্যান্ডম আর কে একটি স্ট্যাটিক ফিল্ডে সরান, যাতে আপনি এটি প্রতিবারই আরম্ভ করবেন না, এটি সামগ্রিক পারফরম্যান্সে সহায়তা করবে!
ফ্যালকো

কেন বিতরণ পরিবর্তন?
পিটার টেলর

4

হাল-ফ্যাসন দোরস্ত

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

public class Trendy implements Player{public String getName(){return "Trendy";}public int[]getMove(String[]a){float h=0,c[]=new float[6];int i=0,l=a[3].length(),p=0;for(;i<l;)c[a[3].charAt(i++)-48]+=(float)i/l;for(i=0;i<6;i++)if(c[i]>h)h=c[p=i];return new int[]{(p+2)%6,p};}}    

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


7
আপনি দয়া করে একাধিক লাইনে কোড ফর্ম্যাট করতে পারেন? এটি কোড গল্ফ নয় ...
mbomb007

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

4

র্যান্ডম গেউসার

এটি সত্যিই সরাসরি-এগিয়ে। এটি কার্যকরভাবে একটি ডি 6 রোল করে এবং তার অনুমানের জন্য আগের রোলটিতে আরও একটি রোল যুক্ত করে। এটি জিতবে না, তবে এটি একটি দুর্দান্ত মানদণ্ড সরবরাহ করবে।

import java.util.Random;

public class RandomGuesser implements Player {
    private final Random rnd = new Random();
    public String getName() { return "RandomGuesser"; }

    public int[] getMove(String[] args) {
        return new int[] { rnd.nextInt(6), rnd.nextInt(6) };
    }
}

4

বিভ্রান্ত, পাইথন 3

অযথা জটিল প্রবেশ entry এমনকি আমি জানি না এটি কী করে।

import sys
from random import *

if len(sys.argv) == 7:
    mn,mg,ms,on,og,os = [list(map(int, v)) for v in sys.argv[1:]]
    s,t = sum(mn+on)%5, sum(mg+og)%5
    n = [0]*3+list(range(6))*5+[5,0,5]
    m = [1,0,5,4]+n[:-2:s//9+1]
    numoptions = [n.extend(n[i+s::5+t]+[i]*i*(6+t)) for i in n[:]] and n
    guessoptions = [m.extend(m[i+t//2::8]+[i]*i*(5+s)) for i in m[:]] and m
    num = choice(numoptions)
    guess = choice(guessoptions)
else:
    num, guess = randint(0, 5), randint(0, 5)

sys.stdout.write('%u %u\n' % (num, guess))

যদিও এই উন্নত অ্যালগরিদম এই টুর্নামেন্টে এলোমেলো চেয়ে খারাপ খারাপ বলে মনে হচ্ছে এবং উল্লেখযোগ্য মেমরি এবং রান-টাইম ব্যবহার করে, এটির 5 %--) এর নির্দিষ্ট মানের জন্য অত্যাশ্চর্য ফলাফল রয়েছে


4

Rainbolt

আমাদের প্রতিপক্ষ অনুমান করা শেষ দুটি সংখ্যার মধ্যে পার্থক্য নিয়ে যায় এবং যোগ করে আমাদের প্রতিপক্ষের সর্বশেষ অনুমানে, মডুলাসটি সন্ধান করে এবং সর্বদা এই সংখ্যাটি নির্বাচন করা এড়িয়ে যায়। উদাহরণস্বরূপ, আপনি যদি {5,4,3 gu (একের মাধ্যমে হ্রাস) অনুমান করে থাকেন তবে আমরা 2 ব্যয় করে সর্বদা মূল্য এড়ানো উচিত would

আমাদের প্রতিপক্ষ চয়ন করা শেষ দুটি সংখ্যার মধ্যে পার্থক্য নিয়ে যায়, এটি আমাদের প্রতিপক্ষের সর্বশেষ পছন্দটিতে যোগ করে এবং সেই সংখ্যাটি অনুমান করে। উদাহরণস্বরূপ, আপনি যদি অনুমান করেন {1,4,5,2। (ত্রিশের দ্বারা বৃদ্ধি পাচ্ছে) তবে আমাদের অনুমান 5।

অর্থহীন বা অর্থহীন রোলগুলির খুব কাছে এড়ানো যায়।

public class Rainbolt implements Player {

    public String getName() { 
        return "Rainbolt"; 
    }

    public int[] getMove(String[] args) {
        int[] yourChoices = toIntArray(args[3]);
        int[] yourGuesses = toIntArray(args[4]);

        int myChoice;
        if (yourGuesses.length > 1) {
            int latest = yourGuesses[yourGuesses.length - 1];
            int secondLatest = yourGuesses[yourGuesses.length - 2];
            int numberToAvoid = (2 * latest - secondLatest + 6) % 6;
            do {
                myChoice = rollRandom();
            } while (myChoice == numberToAvoid);
        } else { 
            myChoice = rollRandom();
        }

        int myGuess;
        if (yourChoices.length > 1) {
            int latest = yourChoices[yourChoices.length - 1];
            int secondLatest = yourChoices[yourChoices.length - 2];
            myGuess = (2 * latest - secondLatest + 6) % 6;
        } else { 
            myGuess = rollRandom();
        }

        if ((myChoice + myGuess) < 3) {
            do {
                myGuess = rollRandom();
            } while ((myChoice + myGuess) < 3);
        }

        return new int[] { myChoice, myGuess };
    }

    private static int[] toIntArray(String arg) {
        int[] result = new int[arg.length()];
        for (int i = 0; i < arg.length(); i++)
            result[i] = Character.getNumericValue(arg.charAt(i));
        return result;
    }

    private static int rollRandom() {
        return (int) (Math.random() * 6);
    }
}

আপনার getMove()পদ্ধতি স্থির করবেন না । আপনি এটির মতো কোনও স্থিতিশীল পদ্ধতি প্রয়োগ করতে পারবেন না (অন্তত জাভা 8 তে নয়)।
জায়ান্ট্রি ট্রি

@ গ্রেট্রি ট্রি এটি ধরার জন্য ধন্যবাদ।
রেইনবোল্ট

3

বিবর্তিত বট

আমি এই বটটি সেরা এলোমেলো ভিত্তিক বট হিসাবে বিবর্তিত করেছি।

import java.util.Arrays;

public class EvolvedBot implements Player {

    private static final double MUTATION_RATE = .2;
    private static final double CROSS_OVER_RATE = .5;

    private final double[] pickProbabilities;
    private final double pickSum;
    private final double[] guessProbabilities;
    private final double guessSum;

    public EvolvedBot(){
        this(new double[]{1.0069058661897903, 0.8949716031797937, 0.5249198534098369, 0.437811964976626, 0.2630925750209125, 0.4862172884617061},
                new double[]{0.6336558074769376, 0.13700756148363913, 0.9586621925124863, 0.11223159366330251, 0.8931390659502754, 0.662974949440039});
    }

    public EvolvedBot(double[] pickProbabilities, double[] guessProbabilities) {
        this.pickProbabilities = pickProbabilities;
        this.guessProbabilities = guessProbabilities;
        pickSum = Arrays.stream(pickProbabilities).sum();
        guessSum = Arrays.stream(guessProbabilities).sum();
    }

    @Override
    public String getName() {
        return "EvolvedBot"/* + ": " + Arrays.toString(pickProbabilities) + Arrays.toString(guessProbabilities)*/;
    }

    @Override
    public int[] getMove(String[] args) {
        int[] move = new int[]{5, 5};
        double pick = Math.random() * pickSum;
        double guess = Math.random() * guessSum;
        for (int i = 0; i < 6; i++){
            if (pick >= 0) {
                pick -= pickProbabilities[i];
                if (pick < 0) {
                    move[0] = i;
                }
            }
            if (guess >= 0){
                guess -= guessProbabilities[i];
                if (guess < 0){
                    move[1] = i;
                }
            }
        }
        return move;
    }

    public EvolvedBot mutate(double mutationRate){
        double[] pickProbabilities = Arrays.copyOf(this.pickProbabilities, 6);
        double[] guessProbabilities = Arrays.copyOf(this.guessProbabilities, 6);

        for (int i = 0; i < 6; i++){
            pickProbabilities[i] = Math.max(pickProbabilities[i] + (Math.random() * 2 - 1) * mutationRate, 0);
        }

        for (int i = 0; i < 6; i++){
            guessProbabilities[i] = Math.max(guessProbabilities[i] + (Math.random() * 2 - 1) * mutationRate, 0);
        }

        return new EvolvedBot(pickProbabilities, guessProbabilities);
    }

}

3

জনপ্রিয়তা, পাইথন 3

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

import sys
from random import *

if len(sys.argv) == 7:
    mn,mg,ms,on,og,os = [list(map(int, v)) for v in sys.argv[1:]]
    n = list(range(6))
    guess = choice(n + on[-100:] + on[-20:]*8)
    num = choice(n + [guess]*6)
else:
    num, guess = randint(0, 5), randint(0, 5)

sys.stdout.write('%u %u\n' % (num, guess))

3

প্রক্ষেপক

(পাইথন যেহেতু জাভাতে স্যুইচ করা সমস্যা তৈরি করছে)

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

  • যদি এটি 0 অনুমান করে তবে এটি কখনই 0 টি পছন্দ করবে না
  • যদি এটি 5 অনুমান করে তবে সর্বদা 0 বা 1 চয়ন করবে
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class Interpolator implements Player
{
    private final int TAIL_LENGTH = 10;

    public String getName()
    {
        return "Interpolator";
    }

    public int[] toInts(String s) {
        char [] chars = s.toCharArray();
        int[] ints = new int[chars.length];

        for (int i = 0; i < chars.length; i++){
            ints[i] = Integer.parseInt(Character.toString(chars[i]));
        }

        return ints;
    }

    public int mod6(int n) {
        n = n % 6;
        if (n < 0) { n += 6; }
        return n;
    }

    public int interpolate(int[] nums){
        boolean allEqual = true;

        for (int i = 0; i < nums.length; i++){
            if (nums[i] != nums[0]){
                allEqual = false;
            }
        }

        if (allEqual) {
            return nums[0];

        } else {
            int [] newNums = new int[nums.length - 1];

            for (int i = 0; i < nums.length - 1; i++){
                newNums[i] = nums[i+1] - nums[i];
            }

            return nums[nums.length - 1] + interpolate(newNums);
        }
    }

    public int[] tail(int[] nums) {
        int minLength = Math.min(TAIL_LENGTH, nums.length);
        int[] tailArray = new int[minLength];

        for (int i = 0; i < minLength; i++){
            tailArray[i] = nums[nums.length - minLength + i];
        }

        return tailArray;
    }

    public int[] getMove(String [] args)
    {
        Random r = new Random();

        if (args[0].length() == 0){
            return new int[] {r.nextInt(5), r.nextInt(5)};
        }

        int[] myChoices = toInts(args[0]);
        int[] opponentChoices = toInts(args[3]);
        int[] opponentGuesses = toInts(args[4]);

        int guess = mod6(interpolate(tail(opponentChoices)));
        int avoid = mod6(interpolate(tail(myChoices)));

        if (guess == 5){ return new int[] {r.nextInt(2), 5}; }

        int[] choiceArray = {0, 1, 1, 2, 2, 3, 3, 4, 4, 5};
        ArrayList<Integer> choices = new ArrayList<Integer>();
        for (int i = 0; i < choiceArray.length; i++) { choices.add(choiceArray[i]); }

        choices.removeAll(Collections.singleton((Integer) avoid));
        if (guess <= 0) { choices.removeAll(Collections.singleton((Integer) 0)); }
        int choice = choices.get(r.nextInt(choices.size())); 

        return new int[] {choice, guess};
    }
}

3

CounterBot

না কাউন্টার কেউ বরং একটি বৃত্তে 0-5 মাধ্যমে গন্য ( 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4 ...)

import java.util.Random;

public class Counter implements Player {

    int lastChoice = new Random().nextInt(6); //Chooses a random starting number

    public String getName() {
        return "CounterBot";
    }

    public int[] getMove(String[] args) {
        int[] oChoices = new int[6]; //Array to store the amount of individual choices of the opponent

        for (int i = 0; i < args[3].length(); i++) {
            int index = Integer.parseInt(String.valueOf(args[3].charAt(i))); //get that choice
            oChoices[index]++; //Increment the number corresponding the choice
        }
        int guess = 0, last = 0;
        for (int i = 0; i < oChoices.length; i++) { //Increment over the choices' array
            if (oChoices[i] > last) { //If the number has been chosen more often than the one before
                last = oChoices[i]; //Set the new maximum value (later the last maximum value)
                guess = i; //Set it as the next guess
            }
        }
        lastChoice++; //Increment our choice
        lastChoice %= 6; //Make sure it's within the bounds of 0-5 ie. modulo 6 (6 modulo 6 = 0)
        return new int[]{lastChoice, guess}; //return our choice and guess
    }
}

2

বাসিলিস্ক, পাইথন

জনশ্রুতি অনুসারে, বাসিলিস্ক হ'ল সর্পের রাজা। ( উত্স ) আমি বুঝতে পেরেছিলাম যে এটি এমন একটি বটের উপযুক্ত নাম যা "দ্য নোবেল গেম অফ কিংস" খায় এবং অজগরে লেখা থাকে। = ডি এই বটটি অন্য বটগুলির হৃদয়ে ভয়কে আঘাত করে এবং এক নজরে মৃত্যুর কারণ করে।

import sys
import random

args = sys.argv
argc = len(args)
if argc < 6:
    sys.exit()

myChoices = args[1]
myGuesses = args[2]
myScore = args[3]
opponentChoices = args[4]
opponentGuesses = args[5]
opponentScore = args[6]

if len(myChoices) == 0:
    print (random.randint(0, 5))
    print (random.randint(0, 5))
    sys.exit()

guesses = [0, 0, 0, 0, 0, 0]
for char in opponentGuesses:
    i = int(char)
    guesses[i] += 1

#Will default towards smaller guesses to minimize opponent winnings
#For example, if the guess list is
#[5, 3, 7, 3, 4, 8]
#This will return 1. (index of the first 3)
myNextMove = guesses.index(min(guesses))

list = [
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0]]
i = 0

while i < len(myGuesses) - 1:
    myGuess = int(myGuesses[i])
    opponentResponse = int(opponentChoices[i+1])
    list[myGuess][opponentResponse] += 1
    i += 1

myPreviousGuess = int(myGuesses[-1])
relevantList = list[myPreviousGuess]

#Defaults towards higher moves.
#For example, if the list is
#[3, 8, 6, 8, 0, 7]
#This will return 3 (index of the last 8)
highestValue = -1
highestIndex = -1
for i in range(len(relevantList)):
    if relevantList[i] >= highestValue:
        highestValue = relevantList[i]
        highestIndex = i


myNextGuess = highestIndex

print (myNextMove)
print (myNextGuess)

এটি একটি দুর্দান্ত সরল কৌশল নিয়ে চলে। আমি এটি জয়ের আশা করি না, তবে এটি মজাদার ছিল। এটিও আমার প্রথম কোএইচটি চ্যালেঞ্জ, সুতরাং এটি কতটা দুর্দান্ত পারফর্ম করে তা দেখে আমি আনন্দিত।

কীভাবে এটি তার পরবর্তী পদক্ষেপটি তুলে ধরে।

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

কীভাবে এটি তার পরবর্তী অনুমান করে।

বেসিলিস্ক তার পূর্ববর্তী অনুমানের সবচেয়ে সম্ভবত প্রতিক্রিয়া বেছে নেবে। উদাহরণস্বরূপ, গতবার যদি এটি 3 অনুমান করেছিল তবে পূর্ববর্তী সময়ে এটি 3 অনুমান করেছিল এবং এটি আবার অনুমানের পরে উপস্থিত সবচেয়ে সাধারণ প্রতিপক্ষের পদক্ষেপটি ফিরে আসবে a টাইয়ের ক্ষেত্রে , এটি বৃহত্তর সংখ্যাটি বেছে নেবে (এটি তৈরি করতে সক্ষম পয়েন্টগুলির সংখ্যা সর্বাধিক করতে)

প্রযুক্তিগত নোটে, এটি কি সঠিকভাবে চলবে? মুদ্রণ কি যথেষ্ট?


sys.stdout.write () পাইথন দুটিতে কাজ করে। মুদ্রণ () কেবল পাইথন 3 এ কাজ করে It যদিও এটি ঠিক আছে।
TheNumberOne

না, মুদ্রণ () এর মধ্যে কাজ করে, আমি এটি সম্পর্কে নিশ্চিত। প্রথম বন্ধনী 2.x মধ্যে ঐচ্ছিক
DJMcMayhem

এই অনুসারে , তারা ভিন্নভাবে কাজ করে। তবে আপনি যেভাবে এটি ব্যবহার করছেন তাতে কিছু আসে যায় না।
TheNumberOne

কিন্তু এতে কি কোনও পার্থক্য রয়েছে?
DJMcMayhem

দৃশ্যত না.
TheNumberOne

2

পূর্বোক্ত

এটি প্রতিপক্ষে পরিণত হয় তবে এক অনুমান / পছন্দ অনুসারে।

import java.util.Random;

public class Ditto implements Player {
    private final Random rnd = new Random();
    public String getName() { return "Ditto"; }

    // myChoices myGuesses myScore oppChoices oppGuesses oppScore
    public int[] getMove(String[] args) {
        if(args[0] == null || args[0].isEmpty()) {
            return new int[] { rnd.nextInt(6), rnd.nextInt(6) };
        }
        int[] myChoices = toIntArray(args[0]);
        int[] myGuesses = toIntArray(args[1]);
        //int myScore = Integer.parseInt(args[2]);
        int[] oppChoices = toIntArray(args[3]);
        int[] oppGuesses = toIntArray(args[4]);
        //int oppScore = Integer.parseInt(args[5]);

        return new int[] { oppChoices[oppChoices.length-1], oppGuesses[oppGuesses.length-1] };
    }

    private static int[] toIntArray(String arg) {
        int[] result = new int[arg.length()];
        for (int i = 0; i < arg.length(); i++)
            result[i] = Character.getNumericValue(arg.charAt(i));
        return result;
    }
}

1

নালিফায়ারবট, জাভা

যে কোনও প্রতিপক্ষের জয় কমাতে সর্বদা 0 টি ছুঁড়ে। প্রতিদ্বন্দ্বী যদি কখনও আমার নম্বর অনুমান করে তবে তারা কেবল যা ফেলেছিল তা অর্জন করে।

আমার বিজয় সর্বাধিকতর করতে সর্বদা 5 টি অনুমান করে। যেহেতু আমি আমার থ্রো থেকে কোনও পয়েন্ট পেতে পারি না, তাই আমি প্রতিপক্ষের কাছ থেকে অনেকগুলি পেতে চাই। আমি এলোমেলোভাবে অনুমান করতে পারি, তবে এর মধ্যে মজা কোথায়?

public class NullifierBot implements Player
{
    public String getName()
    {
        return "NullifierBot";
    }

    public int[] getMove(String [] args)
    {
        // always throws 0 to minimize opponents score
        // always guesses 5 to maximize my score
        return new int[] {0, 5}; 
    }
}

আমি অনুমান করছি যে এই বোটটি ভয়ানকভাবে করবে। প্রতিক্রিয়া ব্যবহার করে যে কোনও বট সম্ভবত প্রথমটির পরেও প্রতিটি একক অনুমান পেতে পারে।
mbomb007

@ mbomb007 যদিও এটি সবচেয়ে খারাপ নয়! যদিও এটি আপনার র‌্যান্ডমবটের চেয়ে খারাপ কাজ করে।
ব্রায়ান জে

1

এরটিকা, জাভা

দুর্দান্ত নয়, তবে মূলত এটিকে বেশিরভাগ এলোমেলোভাবে তৈরি করার জন্য তৈরি করা হয়েছিল, যতক্ষণ না আমার কাছে বাণিজ্য-অফের মূল্য ছড়িয়ে পড়ে। নিয়মিত বনাম কাউন্টার বট> _ <হারাতে সক্ষম

import java.util.Random;
class Erratica implements Player
{
    private final Random rnd = new Random();

    public String getName() {
        return "Erratica";
    }

    public int[] getMove(String[] args) {
        if(args[0] == null || args[0].isEmpty())
        {
            return new int[]{rnd.nextInt(4)/3+4,rnd.nextInt(4)/3};
        }
        int[] myChoices = toIntArray(args[0]);
        int[] myGuesses = toIntArray(args[1]);
        int myScore = Integer.parseInt(args[2]);
        int[] opponentChoices = toIntArray(args[3]);
        int[] opponentGuesses = toIntArray(args[4]);
        int opponentScore = Integer.parseInt(args[5]);
        int round = opponentChoices.length + 1;
        int choice=0;
        int guess=0;
        if(round<7)
        {
            if(rnd.nextFloat()<(0.1f*(float)round-0.1f))
            {
                choice=(opponentChoices[round-2]+opponentGuesses[round-2])%6;
            }else
            {
                choice=rnd.nextInt(6);
            }
            if(rnd.nextFloat()<(0.1f*(float)round-0.1f))
            {
                guess=opponentChoices[round-2];
            }else
            {
                guess=rnd.nextInt(6);
            }
            return new int[]{choice, rnd.nextInt(6)/5*(5-choice-guess)+guess};
        }else
        {
            int lastError=Math.abs(opponentGuesses[round-2]-myChoices[round-2]);
            for(int i=round-2; i>round-8;i--)
            {
                if(lastError<rnd.nextInt(6))
                {
                    lastError++;
                }else
                {
                    lastError--;
                }
                if(lastError<0)
                    lastError+=6;

            }
            lastError = lastError%6; //shouldn't change
            switch(rnd.nextInt(4))
            {
                case 0:
                    choice=(myChoices[round-2-lastError-round/10])%6;
                    break;
                case 1:
                    choice=(myChoices[lastError+round/10])%6;
                    break;
                default:
                    choice = rnd.nextInt(6);
                    break;
            }

            lastError=Math.abs(myGuesses[round-2]-opponentChoices[round-2]);
            for(int i=round-2; i>round-8;i--)
            {
                if(lastError<rnd.nextInt(6))
                {
                    lastError++;
                }else
                {
                    lastError--;
                }
                if(lastError<0)
                    lastError+=6;
            }
            lastError = lastError%6; //shouldn't change
            switch(rnd.nextInt(4))
            {
                case 0:
                    guess=(opponentChoices[round-2-lastError-round/10])%6;
                    break;
                case 1:
                    guess=(opponentChoices[lastError+round/10])%6;
                    break;
                default:
                    guess = rnd.nextInt(4);
                    break;
            }
        }

        if(myScore>opponentScore)
            switch(rnd.nextInt(2)){
                case 0:
                    choice=5-guess;
                    break;
                case 1:
                    guess=5-choice;
                    break;
                default:
                    break;
            }
        return new int[]{choice, guess};
    }

    private static int[] toIntArray(String arg) {
        int[] result = new int[arg.length()];
        for (int i = 0; i < arg.length(); i++)
            result[i] = Character.getNumericValue(arg.charAt(i));
        return result;
    }
}

1

প্রতিধ্বনি, রুবি

mychoices, myguesses, myscore, opponentchoices, opponentguesses, opponentscore = $*

unless mychoices
 puts "0 5"
 exit
end

if mychoices.size > 990 && myscore == '0'
  nextchoice = rand(1..5)
else
  nextchoice = opponentchoices[-1].to_i
end

recentchoices = opponentchoices[/.{0,100}$/]

nextguess = (0..5).max_by do |choice|
  (recentchoices.count(choice.to_s)+1) * (nextchoice + choice)
end

puts "%s %s"%[nextchoice,nextguess]

প্রতিপক্ষের তৈরি সর্বশেষ নাটকটি যে তত্ত্ব অনুসারে যে কেউ বোট করতে পারে যা তারা ভবিষ্যদ্বাণী করতে পারে না। একশত সরানো নমুনা ব্যবহার করে প্রত্যাশা মানের উপর ভিত্তি করে অনুমানগুলি।


আমি এই ত্রুটিটি পাচ্ছি: echo.rb:3:in <main> ': অপরিবর্তিত পদ্ধতি size' for nil:NilClass (NoMethodError)। এটি কেবল প্রথম রাউন্ডেই দেখা যাচ্ছে, যখন কোনও সরানোর ইতিহাস নেই।
PhiNotPi

অদ্ভুত, আমি পরীক্ষা করার সময় ঘটেনি। আমি সম্পাদনা করব।
হিস্টোক্র্যাট

if (mychoices.size > 990 && myscore == '0') nextchoice = rand(1..5)অংশটির প্রাসঙ্গিকতা কী ?
এলোমেলো

যদি এটি একটি স্কোরলেস টাইয়ে শেষ হতে চলেছে (যেমন ঘটবে, উদাহরণস্বরূপ, নিজের বিরুদ্ধে), এটি এলোমেলোভাবে খেলতে শুরু করে, যেহেতু win০% জয়ের সম্ভাবনা কোনও কিছুর চেয়ে ভাল।
হিস্টোক্র্যাট

1

রাজা ফিশার

    import java.util.Random;
public class KingFisher {

    private Random rnd = new Random();
    private int wins = 0;
    private int loses = 0;
    private int median = 0;
    private int medianMoved = 0;
    private int[] weightedLow = {40,65,80,90,95};
    private int[] weightedHigh = {5,15,30,55,95};
    private boolean highWeightMethod = true;

    public String getName() {
        return "KingFisher";
    }

    public int[] getMove(String [] args)
    {
        char[] mc  = args[0].toCharArray();
        char[] mg  = args[1].toCharArray();
        char[] oc  = args[3].toCharArray();
        char[] og  = args[4].toCharArray();
        int len = mc.length;
        int currentGuess = 0;
        int currentChoice = 0;
        if(len < 10)
            return new int[] {rnd.nextInt(6),rnd.nextInt(6)}; 
        int[] guessWeight = {0,0,0,0,0,0};
        int[] guessWeightTotal = {0,0,0,0,0,0};
        for(int a = 0; a< len;a++)
            guessWeight[oc[a]-48]++;
        if(!highWeightMethod){

            int[] whiteList = {1,1,1,1,1,1};
            for(int b = 0;b<3;b++){

                int min = 0;
                int max = 0;
                int minIndex = 0;
                int maxIndex = 0;
                for(int a = 0;a<6;a++){

                    if(whiteList[a] == 1){

                        min = guessWeight[a];
                        max = guessWeight[a];
                        minIndex = a;
                        maxIndex = a;
                        break;
                    }
                }

                for(int a = 0; a<6;a++){

                    if(whiteList[a] == 1){

                        if(guessWeight[a]<min){

                            min = guessWeight[a];
                            minIndex = a;
                        }
                        if(guessWeight[a]>max){

                            max = guessWeight[a];
                            maxIndex = a;
                        }
                    }
                }
                guessWeight[maxIndex] = min;
                guessWeight[minIndex] = max;
                whiteList[maxIndex] = 0;
                whiteList[minIndex] = 0;
            }
        }

        for(int a = 0; a< 6;a++)
            for(int b = 0; b<=a;b++)
                guessWeightTotal[a]+=guessWeight[b];
        int randInt = rnd.nextInt(guessWeightTotal[5]);
        for(int a = 0; a<6;a++){

            if(randInt < guessWeightTotal[a]){
                currentGuess = a;
                break;
            }
        }

        if(mg[len-1] == oc[len-1]){
            wins++;
            median++;
        }
        if(og[len-1] == mc[len-1]){
            loses++;
            median--;
        }
        if(median > 2){

            medianMoved++;
            median = 0;
        }
        if(median < -2){

            medianMoved--;
            median = 0;
        }

        randInt = rnd.nextInt(95);
        if((wins-medianMoved)>(loses+medianMoved)){

            for(int a = 0; a<6;a++){

                if(randInt < weightedLow[a]){
                    currentChoice = a;
                    break;
                }
            }
        }
        else{

            for(int a = 0; a<6;a++){

                if(randInt < weightedHigh[a]){
                    currentChoice = a;
                    break;
                }
            }
        }
        if(medianMoved < -5){

            highWeightMethod = !highWeightMethod;
            medianMoved = 0;
        }
        return new int[] {currentChoice,currentGuess}; 

    }
}

এই লোকটি খারাপ অনুমানের আলগোরিদিমগুলি নিয়ে গঠিত যা বেশিরভাগ ওজনযুক্ত অ্যারে ব্যবহার করে।


পরবর্তী আপডেটে হবে।
PhiNotPi

1

উহ আহ। আমি জানি তুমি কি ভাবছো "সে কি পাঁচ বা অন্য কিছু বাছাই করবে?" আপনাকে এই সমস্ত উত্তেজনায় সত্য বলতে আমি নিজেকে নিশ্চিত নই, তবে এটি হ'ল একটি .44 পদ্ধতি, বিশ্বের সবচেয়ে শক্তিশালী পদ্ধতি এবং এখনই আপনার স্ট্যাকটি ওভারলোড করা উচিত, আপনি নিজেকে একটি প্রশ্ন জিজ্ঞাসা করতে হবে : "আমি কি নিজেকে ভাগ্যবান মনে করি?"

ঠিক আছে, তাই না, পাঙ্ক?

public class DirtyHarry implements Player {

    @Override
    public String getName() {
        return "DirtyHarry";
    }

    @Override
    public int[] getMove(String[] args) {
        return new int[]{5, 5};
    }
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.