হিলের রাজা - লিয়েরস ডাইস

Question

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

• প্রতিটি খেলোয়াড় 5d6 দিয়ে শুরু হয়
• রাউন্ডের শেষে ডাইস টাল করার সময় বাদে প্রতিটি খেলোয়াড় নিজের ডাইস দেখতে পাবে, তবে কোনও প্রতিপক্ষের নয়
• প্রদত্ত যে কোনও রাউন্ডের শুরুতে, সমস্ত খেলোয়াড়ের কাছে বর্তমানে যা ডাইস রয়েছে তা রোল করে
• তারপরে, একজন খেলোয়াড় (সাধারণত, এটি হয় পূর্ববর্তী রাউন্ডের বিজয়ী বা প্লেয়ারটি সর্বশেষে শুরু হওয়া খেলোয়াড়ের বাম দিকে; আমরা এই কোটএইচটির জন্য প্রাক্তনটি ব্যবহার করব; প্রথমবারের মতো একটি এলোমেলো খেলোয়াড়) নির্দিষ্ট সংখ্যার কতটি টেবিলের উপরে রয়েছে সে সম্পর্কে অনুমান করে (তারাই চাইবে)
• বিডিং ডানদিকে অব্যাহত থাকে, প্রতিটি সময় উচ্চতর হয় (উদাহরণস্বরূপ; 3 পাঁচ, 3 ছক্কা এবং 4 টি দ্বিগুণ সমস্ত 3 টি চারের চেয়ে বেশি, তবে 3 ত্রিশ নয়; 4 টিও উচ্চতর তবে বিডিং সম্ভবত আপনাকে একটি স্থানে ফেলবে অসুবিধা); যতক্ষণ না কোনও প্লেয়ার খেলোয়াড়কে তাদের পূর্ববর্তী মিথ্যাবাদী বলে calls
• এই মুহুর্তে, সমস্ত খেলোয়াড় তাদের ডাইস প্রকাশ করে এবং টেবিলে সর্বমোট বিডের সংখ্যাটি সম্পূর্ণ গণনা করে
• যদি বিডের তুলনায় মোট কম হয়, যে খেলোয়াড় বিড তৈরি করেছিল তাকে অবশ্যই মিথ্যাবাদী বলা সেই খেলোয়াড়কে অবশ্যই মরতে হবে, অন্যথায়, যে খেলোয়াড়কে দরদাতাকে মিথ্যাবাদী বলা হয় তাকে অবশ্যই দরদাতাকে একটি ডাই দিতে হবে (সুতরাং বিডির জয়ী সেগুলি যদি তার বিড অনুসারে কমপক্ষে সেই সংখ্যাটির বেশি হয় তবে সঠিক সংখ্যাটি থাকতে হবে না)
• যখন আপনি পাশা থেকে রান, আপনি হারাবেন
• শেষ প্লেয়ার জিতেছে

উদাহরণ স্বরূপ:

খেলোয়াড়ের একজনের 1,1,2,4,6 আছে
প্লেয়ার দু'জনের রয়েছে 1,2,2,3,5
খেলোয়াড় তিনটির 1,3,3,4,6 জন রয়েছে
খেলোয়াড় এক: তিনটি ছক্কা।
খেলোয়াড় দুই: চার জন।
খেলোয়াড় তিন: চার ত্রিশ।
খেলোয়াড় এক: পাঁচ জন
খেলোয়াড় দুই: ছয় জোড়া।
খেলোয়াড় তিন: ছয় ত্রিশ।
খেলোয়াড় এক: ছয়টি বাউন্ডারি।
খেলোয়াড় দুই: মিথ্যাবাদী!
তারা তাদের পাশা প্রকাশ করে এবং গণনা করে (কারণ এটি বন্য) এবং চারটি।
দেখা যাচ্ছে যে সেখানে আসলে ছয়টি বাউন্ডারি রয়েছে।
সুতরাং খেলোয়াড় দুজন খেলোয়াড়কে একটি মরে যায়।
তারা পুনরায় তালিকাভুক্ত করে এবং প্লেয়ার একের পরের রাউন্ডটি শুরু হয়।

এই গেমটি খেলতে আপনাকে অবশ্যই একটি বট লিখতে হবে। এটি অবশ্যই নিম্নলিখিত বিমূর্ত জাভা শ্রেণি প্রয়োগ করতে হবে:

public abstract class Player {
    public Player() {}
    public String toString() {
        return this.getClass().getSimpleName();
    }
    public abstract String bid(int yourId, int[] diceEachPlayerHas, int[] yourDice, String[] bids);
}

• আপনাকে অবশ্যই বিড পদ্ধতিটি প্রয়োগ করতে হবে
  • প্রথম যুক্তি হ'ল টার্ন ক্রমে আপনার বটের বর্তমান অবস্থান, দ্বিতীয়টি হ'ল একটি অ্যারে যা প্রতিটি খেলোয়াড়ের (নিজেকে সহ) বর্তমানে কত ডাইস রয়েছে তা দেখানো হচ্ছে, তৃতীয়টি বর্তমানে আপনার নিজস্ব ডাইসে প্রদর্শিত মানগুলি দেখানো অ্যারে এবং চতুর্থটি বর্তমান রাউন্ড শুরুর পর থেকে তৈরি সমস্ত বিডের একটি অ্যারে - আপনি রাউন্ডের প্রথম বিডটি করেন তবে দৈর্ঘ্য 0 হবে
  • আউটপুটটি হয় "নম্বর মুখ" ফর্মের স্ট্রিং বা "মিথ্যাবাদী!" স্ট্রিং হওয়া উচিত! পূর্ববর্তী দরদাতাকে মিথ্যাবাদী বলতে
  • যদি আপনার আউটপুট অবৈধভাবে ফর্ম্যাট করা হয় তবে আপনি মুছে ফেলা হবে।
• আপনি toString পদ্ধতি ওভাররাইড করতে পারেন, কিন্তু প্রয়োজন হয় না। তবে, আপনি এটিকে কোনওভাবেই সম্পাদনা করতে পারবেন না যা নিয়ামকের আউটপুটটির পাঠযোগ্যতার সাথে হস্তক্ষেপ করে।
• আপনি নিয়ামক অন্য কোন পাবলিক পদ্ধতি ডাকতে অনুমতি দিলেও হয় না তার প্রধান পদ্ধতি।
• আপনি চলমান ডিরেক্টরিতে কেবল নিজের বটের নিজস্ব নামের সাথে পূর্বনির্ধারিত ফাইলগুলি পড়তে এবং সম্পাদনা করতে পারেন
• আপনাকে অন্য কোনও উত্স থেকে ইনপুট নেওয়ার অনুমতি নেই
• প্রতিটি নতুন গেমের শুরুতে ইনস্ট্যান্স ভেরিয়েবলগুলি পুনরায় সেট করা হয়, তবে স্থির ভেরিয়েবলগুলি হয় না।

স্কোরিং

• এক হাজার গেমের একটি সেট, প্রতিটিতে ৩-৫ জন খেলোয়াড়, প্রতিবার একটি বট যুক্ত হওয়ার সাথে সাথে সিমুলেট করা হবে (তিন বা ততোধিক বট জমা দেওয়ার সাথে সাথে), নিয়ামক উত্সে প্রদর্শিত স্কোর (যে কোনও খেলায় আপনি আপনার প্রতিটি টার্নের শুরুতে 1 পান, প্রতিবার আপনি একটি ডাই ক্যাপচার করেন 10 এবং আপনি জিতলে 1,000 বোনাস পান); প্রতিটি গেমের 5000 সীমা (রাউন্ড নয়) সীমা প্রয়োগ করা।
• আপনার বট গেমসের সর্বশেষ সেট থেকে এর স্কোর দ্বারা স্কোর করা হবে; যোগফলের চেয়ে দশগুণ বেশি তার ভোট স্কোর। (পরবর্তীটির স্কোরের উপর উল্লেখযোগ্য প্রভাব পড়ার সম্ভাবনা নেই)

নিয়ামক উত্স এখানে পাওয়া যাবে।

2015-06-19 হিসাবে স্কোর:

Badnomial: 434,924 + 6x10 = 424,984
Nobody: 282,329 + 6x10 = 282,389
StraightShooter: 265,205 + 5x10 = 265,255
MostlyHonestAbe: 158,958 + 4x10 = 158,998
The Pirate: 157,005 + 1x10 = 157,015
Statistician: 144,012 + 2x10 = 144,032
Fidelio: 49,973 + 2x10 = 49,993
Absurd Bot: 6,831
DrHouse: 2,638 + 3x10 = 2,668

Comments

আপনার স্পষ্ট করে বলা উচিত যে আউটপুটটি "2 3" হওয়া উচিত এবং "উদাহরণস্বরূপ" দুটি ত্রি "নয়। এছাড়াও, কোনও একক ম্যাচ দেখার নিয়ামকটির কোনও উপায় আছে?

— কেইন

অফিসিয়াল সংস্করণে নয়, তবে আমি একটি বিকল্প সংস্করণ পোস্ট করব যা আপনাকে এটি করতে দেয়।

— সুপারজেডি ২২৪

@ জিওবিটস: আপনি চাইলে যদি কেউ আপনাকে কল করে তবে এটি আপনাকে কিছুটা অসুবিধে করবে।

— সুপারজেডি ২২৪

আমি ধরে নিয়েছি অ্যারের সূচকগুলি প্লেয়ারদের "আইডিসি", সুতরাং diceEachPlayerHas[yourId]= আপনার ডাইস গণনা, এবং bids[yourId]এটি আপনার প্রথম বিড (বা যদি আপনার প্রথম পালা হয় তবে নাল)। এটা কি ঠিক?

— চার্লস

আমি এমন খেলাগুলি দেখেছি যেখানে কিছু জমা অন্যদের চেয়ে বেশি গেম খেলবে (কেউ নয়: 414 গেমস, স্ট্রেইট শ্যুটার: 409 গেমস)। এটি ন্যায্য নয়, আপনি কি এটি ঠিক করতে পারেন?

— কমনগ্যুই

Answer 1

কেউ

অন্যান্য খেলোয়াড়দের কাছ থেকে পাশা অনুমান করার চেষ্টা করে। অন্যান্য বটকে মিথ্যাবাদী বলুন যদি তা না জানা থাকে তবে কী করা উচিত।

সম্পাদনা করুন: এমন কোনও সমস্যা সমাধান করা হয়েছে যেখানে কেউ চিরকালের জন্য বিড না করে, কখনই মিথ্যাবাদীকে ডাকে না।

public class Nobody extends Player{

    @Override
    public String bid(int myId, int[] diceEachPlayerHas, int[] myDice,
            String[] bids) {
        if (bids.length == 0)
            return "1 2";
        int wilds = 0;
        int players = Controller.numPlayers();
        double myKnowledge = (double)diceEachPlayerHas[myId]/Controller.diceInPlay();
        double previousKnowledge = (double)diceEachPlayerHas[(myId-1+players)%players] / Controller.diceInPlay();
        int[] dice = new int[5];
        for (int i = 0; i < myDice.length; i++) {
            if (myDice[i] == 1) {
                wilds++;
            } else {
                dice[myDice[i]-2]++;
            }
        }
        wilds = (int) (1/myKnowledge+wilds-1)+1;
        for (int i = 2; i <= 6; i++) {
            dice[i-2] += wilds;
        }
        String best = "0 0";
        for (int i = 2; i <= 6; i++) {
            if (Controller.isGreaterThan(dice[i-2] + " " + i, best)) {
                best = dice[i-2] + " " + i;
            }
        }
        if (Controller.isGreaterThan(best, bids[bids.length - 1])) {
            return best;
        }
        if (previousKnowledge > 0.4) {
            int prev = Integer.valueOf(bids[bids.length - 1].split(" ")[0]);
            int prevFace = Integer.valueOf(bids[bids.length - 1].split(" ")[1]);
            if (dice[prevFace - 2] +2 >= prev)
                return (prev+1) + " " + bids[bids.length - 1].split(" ")[1];
        }
        return "Liar!";
    }
}

Comments

আপনার আপডেটের শেষ সেটটি সত্যিই সাহায্য করেছে বলে মনে হচ্ছে।

— সুপারজেডি ২২৪

Answer 2

বদনোমিয়াল, বোট যা দ্বিপদী বিতরণের উপর ভিত্তি করে খারাপ সিদ্ধান্ত নেয়: সম্পাদনা: সম্ভাবনার গণনায় একটি বোকা ভুল স্থির করে এখন পরবর্তী বিডারের পাশাপাশি অ্যাকাউন্টগুলির জন্য অ্যাকাউন্ট।

    public class Badnomial extends Player{
    public String toString() {return "Badnomial";}

  public String bid(int myId, int[] diceEachPlayerHas, int[] myDice, String[] bids) {
  int[] dieCounts = new int[7];
  for(int i:myDice)
   dieCounts[i]++;
  for(int i=2; i<7; i++)
   dieCounts[i] += dieCounts[1];

  if(bids.length > 0)
  {
   String[] lastBid = bids[bids.length - 1].split(" ");
   int bidCount = Integer.valueOf(lastBid[0]);
   int bidDie = Integer.valueOf(lastBid[1]);
   // Check if I hold a better bid
   boolean betterBid = false;
   int myBidDie;
   int myBidCount;
   int myHighestCount = 0;
   int myHighDie = bidDie +1;

   for(int i = 2; i < 7; i++) {
    if(dieCounts[i] >= myHighestCount) {
     myHighestCount = dieCounts[i];
     myHighDie = i;
    }
   } 
    if((myHighestCount > bidCount) || ((myHighestCount == bidCount) && (myHighDie > bidDie))) {
     betterBid = true;
     myBidDie = myHighDie;
     myBidCount = myHighestCount;
     }

   if(betterBid == false) {
    int unknownDice = Controller.diceInPlay() - myDice.length;
    int myDiceNeeded = bidCount - myHighestCount;
 if(myHighDie <= bidDie)
  myDiceNeeded++;
    int previousBidder = myId - 1;
    if(previousBidder < 0)
     previousBidder = Controller.numPlayers() -1;
    int bidderDiceNeeded = bidCount - dieCounts[bidDie] - (int)(diceEachPlayerHas[previousBidder]/3 +1);
    int bidderUnknown = Controller.diceInPlay() - diceEachPlayerHas[previousBidder] -myDice.length;
 int nextBidder = myId + 1;
 if(nextBidder == Controller.numPlayers())
  nextBidder = 0;
 int nbDiceNeeded = myDiceNeeded - (int)(diceEachPlayerHas[nextBidder]/3 +1);
    int nbUnknown = Controller.diceInPlay() - diceEachPlayerHas[nextBidder];
    //float myChances = (unknownDice/3 - myDiceNeeded)/((float)unknownDice/9);
    //float bidderChances = (bidderUnknown/3 - bidderDiceNeeded)/((float)bidderUnknown/9);
    double myChances = 1 - cumBinomialProbability(unknownDice, myDiceNeeded -1);
    double bidderChances;
    if(bidderDiceNeeded > 0)
     bidderChances = 1- cumBinomialProbability(bidderUnknown, bidderDiceNeeded -1);
    else bidderChances = 1.0;
    double nbChances;
    if(nbDiceNeeded > 0)
      nbChances = 1- cumBinomialProbability(nbUnknown, nbDiceNeeded -1 );
    else nbChances = 1.0;
    if(((myChances < .5) && (nbChances <.5)) || (bidderChances < .2))
     return "Liar!";
   }

   return (bidCount+1) + " " + myHighDie;
  }

  return 2 + " " + 2;
 } 

 private double cumBinomialProbability(int n, int k) {
   double sum = 0;
   for(int i = 0; i <=k; i++)
     sum += binomialProbability(n, i);
   return sum;
 }

 private double binomialProbability(int n, int k) {
   double nfact = 1;
   double dfact = 1;
   int greater;
   int lesser;
   if((n-k) > k) {
     greater = n - k;
     lesser = k;
   }
   else {
     greater = k;
     lesser = n-k;
   }
   for(int i = greater+1; i <= n; i++)
     nfact = nfact * i;
   for(int i = 2; i <= lesser; i++)
     dfact = dfact * i;
   return (nfact/dfact)*(Math.pow((1.0/3), k))*Math.pow(2.0/3, (n-k));
 }

}

এটি নির্ধারণ করার চেষ্টা করে যে এটি নিজের জন্য এবং পূর্ববর্তী এবং পরবর্তী বিডির তাদের প্রয়োজনীয় পাশা উপস্থিতির সম্ভাবনার সম্ভাব্য সংখ্যামূলক বাইনোমিয়াল বিতরণের ভিত্তিতে লিয়রকে ব্লাফ করতে বা কল করা উচিত।

মূলত, পূর্ববর্তী দরদাতাকে যদি মিথ্যাবাদী হওয়ার খুব সম্ভাবনা থাকে বা এটি মনে হয় যে এটি এবং পরবর্তী বিডার উভয়ই মিথ্যা বলার সম্ভাবনা বেশি রাখে it

Comments

এই পরিবর্তনগুলির সাথে, Badnomial আসলে অন্যান্য বটগুলির তুলনায় দূরবর্তীভাবে সক্ষম বলে মনে হয়।

— অকার্যকর সম্ভাবনা

Answer 3

স্ট্রেট শ্যুটার

তিনি এটিকে সরাসরি খেলেন এবং ঝাপসা করেন না। অন্যরাও তা ভেবে ভেবে যথেষ্ট অবজ্ঞাপূর্ণ, তাই তিনি খেলায় মোট ডাইসের মোট সংখ্যার (বিডের সাথে মেলে না এমন তার নিজের বিয়োগ বিয়োগ) না করে তিনি কখনই মিথ্যাবাদী বলেন না।

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

আমি ধরে নিচ্ছি ন্যূনতম বিড হয় 2 2। যদি একজনের মারা যাওয়ার (বা বিডিংয়ের) বিডের অনুমতি দেওয়া হয় তবে আমাকে জানান যে আমি এই পরিবর্তনটি করতে পারি।

public class StraightShooter extends Player{
    public String toString(){return "Straight Shooter";}
    public String bid(int me, int[] numDices, int[] dice, String[] bids){
        int[] counts = new int[7];
        double[] expected = new double[7];
        int unknown = Controller.diceInPlay() - dice.length;
        for(int i:dice)
            counts[i]++;
        for(int i=2;i<7;i++)
            expected[i] = counts[i] + unknown / 3d;
        int bidCount = 2;
        int bidDie = 2;
        if(bids.length > 0){
            String[] lastBid = bids[bids.length-1].split(" ");
            bidCount = Integer.valueOf(lastBid[0]);
            bidDie = Integer.valueOf(lastBid[1])+1;
            int possible = Controller.diceInPlay();
            for(int i=2;i<7;i++)
                if(i != bidDie)
                    possible -= counts[i];
            if(bidCount > possible)
                return "Liar!";

            if(bidDie > 6){
                bidDie = 2;
                bidCount++;
            }
        }
        double best = Double.MAX_VALUE;
        int bestCount = bidCount;
        int bestDie = bidDie;
        for(int count=bidCount;count<=Controller.diceInPlay();count++){
            for(int die=bidDie;die<7;die++){
                double score = Math.abs(expected[die]-bidCount);
                if(score < best){
                    best = score;
                    bestCount = count;
                    bestDie = die;
                }
            }
            bidDie = 2;
        }   
        return bestCount + " " + bestDie;
    }
}

Comments

এটি এবং মোস্টলি হোনস্টেবে দু'জনেই মিথ্যাবাদী বা মিথ্যাবাদী বলতে দ্বিধাগ্রস্ত, আমি যখন হাহা পরীক্ষা করি তখন 2000 গানে কিছু গেম চলে। : পি

— কেইন

আমার মধ্যে একই। যদিও এটি ঠিক আছে, কারণ প্রতিটি পালা চূড়ান্ত স্কোরের দিকে অতিরিক্ত পয়েন্ট। যদি আমি শেষ 2000

— টার্ন

আমাকে আবার স্কোরিংয়ের নিয়মগুলি দেখতে হবে। পুরো নতুন গেম এক্সডি

— কেইন

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

— জিওবিটস

আমি নিশ্চিত নই যে এতে অনেক তাত্পর্য হবে। রক্ষণশীল হওয়া এখনও একটি সুবিধা হবে, কেবলমাত্র আপনার মরে যাওয়ার সম্ভাবনা কম। সত্যিকারের জীবনে বেশি লোক যেভাবে না খেলেন তা হ'ল এটি কেবল বিরক্তিকর, তবে একটি বটের কাছে একঘেয়েমি কী?

— জিওবিটস

Answer 4

MostlyHonestAbe

আবে বাকী প্রতিপক্ষের মৃত্যু সম্পর্কে রক্ষণশীল অনুমান করে এবং তারপরে তিনি সৎ থাকেন যতক্ষণ না তিনি ভাবেন যে বর্তমান বিডকে পরাস্ত করার জন্য পর্যাপ্ত ডাইস রয়েছে। এই মুহুর্তে সে একবার ধমক দেয়, তারপরে পরের বার মিথ্যাবাদী বলে।

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;

public class MostlyHonestAbe extends Player{

    final boolean debug = false;
    boolean bluffedOnce = false;
    PrintStream out;
    @Override
    public String bid(int myId, int[] diceEachPlayerHas, int[] myDice, String[] bids) {
        try {
            File f = new File("abe.log.txt");
            out = new PrintStream(f);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            //e.printStackTrace();
        }
        if(debug){
            out = System.out;
        }

        //reset bluff counter on the first round
        if(bids.length < diceEachPlayerHas.length){
            bluffedOnce = false;
        }

        //Is it the first bid?
        if(bids.length == 0){
            out.println("I go first");
            return lowestViableBid(1,1, myDice, diceEachPlayerHas, true);
        }

        out.println("Last bid = " + bids[bids.length - 1]);
        out.print("My Dice = ");
        for(int d : myDice){
            out.print(d + ", ");
        }
        out.println();

        //What was the last bid?
        String[] lastBid = bids[bids.length -1].split(" ");
        return lowestViableBid(Integer.parseInt(lastBid[1]), Integer.parseInt(lastBid[0]), myDice, diceEachPlayerHas, false);


    }

    //Lowest honest bid, or liar
    private String lowestViableBid(int highestVal, int highestCount, int[] myDice, int[] otherDice, boolean firstTurn){

        //Make a better array for the dice
        //Include what the other players probably have
        int wilds = numDie(1, myDice);
        int[] diceCount = new int[6];
        diceCount[0] = wilds;
        int otherPlayerExpectedValue = 0;
        for(int d : otherDice){
            otherPlayerExpectedValue += d;
        }
        otherPlayerExpectedValue -= myDice.length;
        out.println("Number of other dice = " + otherPlayerExpectedValue);
        otherPlayerExpectedValue = otherPlayerExpectedValue / 4;
        //Note: Other player expected value is biased low, counting wilds the number should be divided by 3.

        out.println("playerExpectedVal = " + otherPlayerExpectedValue);
        for(int i = 1; i < 6; i++){
            diceCount[i] = numDie(i + 1, myDice) + wilds + otherPlayerExpectedValue;
        }


        //What's my array look like?
        for(int i = 0; i < diceCount.length; i++){
            out.println("diceVal = " + (i + 1) + ", diceCount = " + diceCount[i]);
        }

        //Can I bid the same number, but higher dice val?
        for(int diceVal = highestVal + 1; diceVal <= 6; diceVal++){
            if(diceCount[diceVal - 1] >= highestCount){ 
                out.println("1.Returning " + highestCount + " " + diceVal);
                return highestCount + " " + diceVal; }  
        }

        //What about more dice?
        for(int diceNum = highestCount + 1; diceNum <= myDice.length; diceNum++){
            for(int diceVal = highestVal + 1; diceVal <= 6; diceVal++){
                if(diceCount[diceVal - 1] == diceNum){ 
                    out.println("2.Returning " + (diceNum) + " " + diceVal);
                    return (diceNum) + " " + diceVal; } 
            }
        }

        if(firstTurn){ return "1 2"; }
        //If this is the first time I'm out of my league, bluff a round before calling liar.
        if(!bluffedOnce){
            out.println("bluffing " + (highestCount + 1) + " " + highestVal);
            bluffedOnce = true;
            return (highestCount + 1) + " " + highestVal;
        }
        out.println("Returning Liar!");
        //Well, wouldn't want to lie
        return "Liar!";
    }

    private int numDie(int i, int[] myDice){
        int result = 0;
        for(int j : myDice){
            if(i == j){ result++; }
        }
        return result;
    }
}

Comments

তুমি কি আমার সাথে মজা করছো? আমি হোস্টেবে পোস্ট করা থেকে পাঁচ মিনিটেরও কম ছিলাম । এখন আমি একটি নতুন নাম চিন্তা করতে হবে: পি

— জিওবিটস

নামে কোথাও আব্রাহাম লিংকন রেফারেন্স ব্যতীত নামে লায়ারের সাথে কোন খেলা থাকতে পারে না।

— কেইন

Answer 5

হাউস ড

সবাই মিথ্যা বলে!

public class DrHouse extends Player
{   
  public String bid(int yourId, int[] diceEachPlayerHas, int[] yourDice, String[] bids)
  {
    return "Liar!";
  }
}

Comments

আমি যখন আপনার প্রথম দফায় দাবির জন্য বিশেষ যুক্তি যুক্ত করার পরামর্শ দিই suggest

— সুপারজেডি ২৪

@ সুপারজেডি ২২২ আমি কল্পনা করেছি যে বটটি তখন নিয়ামককে বলে যে এটিই মিথ্যাবাদী হওয়ার তার পালা

— নাথান মেরিল

আমার দিনকে LOL করেছেন

— রোহান ঝুনঝুনওয়ালা

Answer 6

Fidelio

এই বট জানে যে কেবলমাত্র তার সবচেয়ে পুনরাবৃত্তি মানই তাকে বিজয়ের দিকে পরিচালিত করবে, তাই তিনি এটির সাথে আঁকড়ে থাকেন। তিনি ধরে নিয়েছেন যে প্রত্যেকের ডাইসের একটি অংশ রয়েছে যা তার সমান, যদি কেউ এই অংশের চেয়ে বেশি দাম দেয়, তবে সে ধরে নেয় যে সে মিথ্যাবাদী।

public class Fidelio extends Player
{
    final String LIAR ="Liar!";
    @Override
    public String bid(int yourId, 
            int[] diceEachPlayerHas, 
            int[] yourDice,
            String[] bids) 
    {
        int[] myDices = new int[6];
        int valueToBid=1;
        for(int i : yourDice)
            myDices[i-1]++;
        for(int i=2;i<myDices.length;i++)
            if(myDices[i]>=myDices[valueToBid])
                valueToBid=i;
        if(bids.length==0)
            return 2+" "+valueToBid;
        int sum=0;
        String[] lastBidString=bids[bids.length-1].split(" ");
        int[] lastBid = new int[2];
        lastBid[0] = Integer.parseInt(lastBidString[0]);
        lastBid[1] = Integer.parseInt(lastBidString[1])-1;
        for(int i : diceEachPlayerHas)
            sum+=i;
        sum-=yourDice.length;
        if(lastBid[0]>sum/3+myDices[lastBid[1]]+myDices[0])
            return LIAR;
        if(lastBid[1]>= valueToBid)
        {
            if(lastBid[0]>=myDices[0]+myDices[valueToBid]+sum*2/5)
                return LIAR;
            return (lastBid[0]+1)+" "+myDices[valueToBid];
        }
        return lastBid[0]+" "+valueToBid;
    }
}

আশা করি তিনি কিছু ভাল কাজ করবেন :)।

Comments

আমি ১৩ ই লাইনে একটি সূচিপত্রআউটবাউন্ডসেক্সপশন পাচ্ছি Remember মনে রাখবেন যে জাভাতে অ্যারেগুলি 0-সূচিযুক্ত।

— সুপারজেডি ২২৪

এখন আমি লাইন 19 এর অন্য প্রান্তে পেয়ে যাচ্ছি, -1 এর সূচকের জন্য। এটি প্রদর্শিত হবে যে এটি খালি অ্যারে থেকে শেষ উপাদানটি পড়ার চেষ্টা করছে, আপনার এটির জন্য একটি চেক অন্তর্ভুক্ত করা উচিত।

— সুপারজেডি ২২৪

স্থির, (বিডস দৈর্ঘ্য == 0) চেকটি আমি বিড ব্যবহার করার পরে করা হয়েছিল

— কিনা

ওহ, আমি আরও একটি সম্ভাব্য সমাধানের প্রস্তাব দিয়েছি, তবে সম্ভবত এটিও কার্যকর হবে।

— সুপারজেডি ২২৪

আহ, সুতরাং এই প্রস্তাবিত সম্পাদনার আর দরকার নেই?

— mbomb007

Answer 7

পরিসংখ্যানবিৎ

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

public class Statistician extends Player{
    public String toString(){return "Statistician";}
    public String bid(int me, int[] numDices, int[] dice, String[] bids){
        int totalDices = 0;
        int currentBid, max;
        for (int i : numDices)
            totalDices += i;
        max = totalDices/3;
        if(bids.length>0){
            currentBid = Integer.valueOf(bids[bids.length-1].split(" ")[0]);
            if(currentBid>max)
                return "Liar!";
        }
        return max+" 6";
    }
}

Answer 8

অ্যাবসর্ড বট

দাবি করে যে ডাইস সবগুলি 6 এর হয় যদি না পারে তবে। বট যদি এটি করতে না পারে তবে এর অর্থ এটি একটি অসম্ভব পরিস্থিতি বা প্রায় অসম্ভব পরিস্থিতি। এ কারণে এটি মিথ্যাবাদী বলে। এই বটটি কতটা কার্যকর হবে তা সম্পর্কে আমি কৌতূহল বোধ করি।

public class AbsurdBot extends Player {
    @Override
    public String bid(int yourId, int[] diceEachPlayerHas,int[] yourDice,String[] bids)
    {
        String[] lastbid;
        int a, b, d;
        d = 0;
        for (int dice : diceEachPlayerHas)
            d += dice;
        if (bids.length != 0)
            {
                lastbid = bids[bids.length-1].split(" ");
                a = Integer.parseInt(lastbid[0]);
                b = Integer.parseInt(lastbid[1]);
                if (a > d || a == d && b == 6)
                    return "Liar!";
            }
        return d + " 6";
    }
}

Comments

— যতটা

@ জিওবিটস আমি কোডটি স্থির করেছি। আপনি প্রোগ্রামিং ভাষায় ঝাঁপিয়ে পড়ার চেষ্টা করেন যা আপনি আগে প্রোগ্রাম করেননি ...

— ফ্রেডেরিক

@ জিওবিটস সমস্ত সহায়তার জন্য ধন্যবাদ। আমি মনে করি এটি শেষ পর্যন্ত এখন সঠিকভাবে কাজ করে। এটা কি পারে? (জাভা বিভ্রান্তিমূলক)

— ফ্রেডেরিক

হ্যাঁ, এটি এখন চলছে। কৌশলটি অত্যন্ত আত্মঘাতী, যদিও। এটি পরের সর্বনিম্ন খেলোয়াড়ের মাত্র ~ 2% স্কোর করে।

— জিওবিটস

@ জিওবিটস আমি অন্য খেলোয়াড়দের বিরুদ্ধে এটি চালানোর চেষ্টা করিনি। আপনি কি অন্যদের বিরুদ্ধে এটি চালিয়েছেন?

— ফ্রেডরিক

Answer 9

জলদস্যু

নিয়ামকটি পরীক্ষা করার সময় আমি কয়েকটি সাধারণ বট তৈরি করেছি এবং এটিই কেবলমাত্র কোনও ভাল।

সম্ভবত পরে উন্নত করা হবে।

import java.util.Arrays;
import java.util.Scanner;

public class Pirate extends Player{
    public Pirate() {
    }
    public String toString(){
        return "The Pirate";
    }
    private String bid(int[] t,int tol){
        int[]z=t.clone();
        Arrays.sort(z);
        int j=0;
        for(int i=0;i<6;i++){
            if(t[i]==z[5]){j=i;break ;}
        }
        return (tol+t[j])+" "+(j+1);
    }
    @Override
    public String bid(int yourId, int[] diceEachPlayerHas, int[] yourDice,
            String[] bids) {
        int[] t=new int[6];
        for(int i=0;i<yourDice.length;i++){
            t[yourDice[i]-1]++;
        }
        for(int i=1;i<t.length;i++)t[i]+=t[0];
        int tol=(Controller.diceInPlay()-yourDice.length)/4;
        if(bids.length==0)return bid(t,1);
        Scanner i=new Scanner(bids[bids.length-1]);
        int x=i.nextInt(),y=i.nextInt();
        i.close();
        if(t[y-1]>x)return (t[y-1]+2)+" "+y;
        int nd=Controller.diceInPlay();
        if(x>nd+t[y-1]-yourDice.length)return "Liar!";
        if(Controller.isGreaterThan(bid(t,tol), bids[bids.length-1])){
            int z=Controller.valueOf(bids[bids.length-1]);
            for(int j=1;j<=tol;j++)if(Controller.valueOf(bid(t,j))>z)return bid(t,j);
        }
        return "Liar!";
    }
}