Liar's Dice adalah game dadu yang cukup sederhana. Saya telah melihat beberapa variasi peraturan yang berbeda, tetapi ini adalah versi yang paling saya kenal:

• Setiap pemain mulai dengan 5d6
• Kecuali ketika menghitung dadu pada akhir ronde, setiap pemain dapat melihat dadu mereka sendiri, tetapi tidak dari lawan mana pun
• Di awal setiap babak, semua pemain melempar dadu apa pun yang mereka miliki saat ini
• Kemudian, satu pemain (biasanya, ini adalah pemenang babak sebelumnya ATAU pemain di sebelah kiri pemain yang memulai terakhir kali; kami akan menggunakan yang pertama untuk KotH ini; dengan pemain acak memulai babak pertama) membuat perkiraan tentang berapa banyak nomor tertentu yang ada di atas meja (SATU-SATUNYA AKAN)
• Penawaran terus ke kanan, naik lebih tinggi setiap kali (misalnya; 3 balita, 3 enam dan 4 dua semuanya lebih tinggi dari 3 merangkak, tetapi 3 bertiga tidak; 4 yang juga lebih tinggi tetapi penawaran yang mungkin akan menempatkan Anda pada kerugian); sampai pemain mana pun memanggil pemain yang mendahului mereka pembohong
• Pada titik ini, semua pemain mengungkapkan dadu mereka dan menghitung jumlah tawaran nomor terakhir di atas meja sama sekali
• Jika total lebih rendah dari tawaran, pemain yang mengajukan penawaran harus memberikan dadu kepada pemain yang menyebut mereka pembohong, jika tidak, pemain yang menyebut penawar pembohong harus memberikan dadu kepada penawar (sehingga penawar menang jika jumlah mereka setidaknya sebanyak yang dia tawarkan, tidak harus ada angka pastinya)
• Saat Anda kehabisan dadu, Anda kalah
• Posisi pemain terakhir menang

Sebagai contoh:

Pemain satu memiliki 1,1,2,4,6
Pemain dua memiliki 1,2,2,3,5
Pemain tiga memiliki 1,3,3,4,6
Pemain satu: tiga enam.
Pemain dua: empat berpasangan.
Pemain tiga: empat bertiga.
Pemain satu: lima berpasangan.
Pemain dua: enam berpasangan.
Pemain tiga: enam bertiga.
Pemain satu: enam merangkak.
Pemain dua: Pembohong!
Mereka mengungkapkan dadu mereka dan menghitung yang (karena yang liar) dan merangkak.
Ternyata ada, tepatnya, empat merangkak.
Jadi pemain dua memberi pemain satu mati.
Mereka memainkan kembali dan pemain satu memulai babak berikutnya.

Anda harus menulis bot untuk memainkan game ini. Itu harus mengimplementasikan kelas java abstrak berikut:

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);
}

• Anda harus menerapkan metode penawaran
  • Argumen pertama adalah posisi bot Anda saat ini dalam urutan belokan, yang kedua adalah array yang menunjukkan berapa banyak dadu yang dimiliki setiap pemain (termasuk diri Anda) saat ini, yang ketiga adalah array yang menunjukkan nilai yang saat ini ditampilkan pada dadu Anda sendiri, dan yang keempat adalah sebuah array dari semua penawaran yang dibuat sejak awal putaran saat ini - akan memiliki panjang 0 jika Anda mengajukan tawaran pertama dari putaran tersebut
  • Outputnya harus berupa string dari bentuk "angka", atau string "Pembohong!" untuk menyebut penawar sebelumnya pembohong.
  • Jika output Anda diformat secara ilegal, Anda akan dihilangkan.
• Anda dapat mengganti metode toString, tetapi tidak diharuskan untuk melakukannya. Namun, Anda tidak boleh mengeditnya dengan cara apa pun yang mengganggu keterbacaan output pengontrol.
• Anda diizinkan memanggil metode publik lain dari pengontrol, tetapi bukan metode utamanya.
• Anda dapat membaca dan mengedit hanya file di direktori yang sedang berjalan yang diawali dengan nama bot Anda sendiri
• Anda tidak diizinkan mengambil input dari sumber lain mana pun
• Variabel instan direset pada awal setiap game baru, tetapi variabel statis tidak.

Mencetak gol

• Satu set 1.000 permainan, dengan 3-5 pemain di masing-masing, akan disimulasikan setiap kali bot ditambahkan (segera setelah tiga bot atau lebih telah diajukan), diberi skor seperti yang ditunjukkan dalam sumber pengontrol (dalam permainan tertentu, Anda dapatkan 1 di awal setiap giliran Anda, 10 setiap kali Anda menangkap mati, dan 1.000 bonus jika Anda menang); menegakkan batas 5.000 TURNS (bukan putaran) setiap game.
• Bot Anda akan dinilai berdasarkan skornya dari set game terbaru; ditambah sepuluh kali skor suaranya, jika tidak negatif. (Yang terakhir tidak mungkin memiliki efek signifikan pada skor)

Sumber pengontrol dapat ditemukan di sini.

Skor per 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

Tak seorangpun

Mencoba menebak dadu dari pemain lain. Panggilan pembohong bot lain jika tidak tahu harus berbuat apa.

Sunting: Memperbaiki masalah di mana Tidak ada yang akan menawar selamanya, tidak pernah memanggil Liar.

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!";
    }
}

Badnomial, bot yang membuat keputusan buruk berdasarkan distribusi binomial: Sunting: Memperbaiki kesalahan bodoh dalam perhitungan probabilitas, sekarang menyumbang pada Penawar berikutnya dan juga sebelumnya.

    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));
 }

}

Ia mencoba untuk menentukan apakah ia harus menggertak atau memanggil Liar berdasarkan perkiraan distribusi binomial kumulatif untuk dirinya sendiri dan peluang bidder sebelumnya dan berikutnya untuk memiliki dadu yang mereka butuhkan.

Pada dasarnya, ini memanggil Liar jika Penawar sebelumnya sangat mungkin menjadi Pembohong atau jika merasa bahwa baik Penawar itu maupun Penawar berikutnya lebih cenderung berbohong daripada tidak.

Penembak lurus

Dia memainkannya lurus dan tidak menggertak. Dia juga cukup naif untuk berpikir bahwa orang lain juga begitu, jadi dia tidak pernah menyebut pembohong kecuali tawaran melampaui jumlah total dadu yang dimainkan (dikurangi dadu sendiri yang tidak cocok dengan tawaran).

Untuk menjadi sedikit lebih konservatif daripada jumlah yang diharapkan untuk setiap mati, ia tidak menghitung binatang buasnya sendiri, tetapi mengasumsikan orang lain memiliki distribusi yang seragam. Dengan empat pemain saat ini, dia atau MostlyHonestAbe tampil lebih dulu setiap kali, dengan skor yang cukup dekat.

Saya mengasumsikan tawaran minimum adalah 2 2. Jika tawaran satu mati (atau penawaran) diizinkan, beri tahu saya agar saya dapat melakukan perubahan itu.

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;
    }
}

MostlyHonestAbe

Abe membuat tebakan konservatif tentang sisa lawan yang mati, dan kemudian tetap jujur ​​sampai dia tidak berpikir ada cukup dadu untuk mengalahkan tawaran saat ini. Pada titik ini dia menggertak sekali, lalu memanggil pembohong di waktu berikutnya.

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;
    }
}

Dr House

Semua orang berbohong!

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

Fidelio

Bot ini tahu bahwa hanya nilainya yang paling berulang yang akan membawanya ke kemenangan, jadi dia tetap menggunakannya. Dia menganggap ada sebagian dadu semua orang yang sama dengan miliknya, jika ada yang menawar lebih dari itu, dia menganggap dia pembohong.

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;
    }
}

Saya harap dia akan melakukan pekerjaan yang baik :).

Ahli statistik

Anda memiliki 1/3 peluang memiliki nomor selain ace. Seorang pria pernah mengatakan kepada saya bahwa tidak memeriksa dadu Anda dan hanya mengetahui kemungkinan dapat membuat Anda memenangkan permainan ini. EDIT: Itu penawaran terlalu tinggi. Tetapi itu tidak banyak meningkatkan skor.

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";
    }
}

Bot Absurd

Membuat klaim bahwa semua dadu adalah 6 kecuali jika tidak bisa. Jika bot tidak dapat melakukan itu, ini berarti bahwa ini adalah situasi yang tidak mungkin atau hampir tidak mungkin. Karena itu, ini disebut pembohong. Saya ingin tahu seberapa efektif bot ini nantinya.

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";
    }
}

Bajak laut

Saya membuat beberapa bot sederhana saat menguji controller, dan ini adalah satu-satunya yang benar-benar bagus.

Kemungkinan akan diperbaiki nanti.

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!";
    }
}