嘘つきのサイコロはかなりシンプルなサイコロゲームです。ルールにはいくつかの異なるバリエーションがありますが、最もよく知っているバージョンは次のとおりです。

• 各プレイヤーは5d6で始まります
• ラウンドの終わりにサイコロを集計する場合を除き、各プレイヤーは自分のサイコロを見ることができますが、どの敵のものも見ることはできません
• 任意のラウンドの開始時に、すべてのプレイヤーは現在持っているサイコロを転がします
• 次に、1人のプレーヤー（通常、これは前のラウンドの勝者または前回開始したプレーヤーの左側のプレーヤーのいずれかです。このKotHには前者を使用します。ランダムなプレーヤーが最初のラウンドを開始します）テーブルに特定の数字がいくつあるかを推測します（ONES ARE WILD）
• 入札は右側に続き、毎回高くなります（たとえば、3 5、3 6、4 2はすべて3 4よりも高くなりますが、3 3はそうではありません。4が高くなりますが、1に入札するとおそらく不利益）; いずれかのプレイヤーがその前のプレイヤーを嘘つきと呼ぶまで
• この時点で、すべてのプレイヤーはサイコロを公開し、テーブルで最後に入札した数をすべてカウントします
• 合計が入札よりも低い場合、入札を行ったプレーヤーは、彼らを嘘つきと呼んだプレーヤーにダイスを与えなければなりません。そうでなければ、入札者を嘘つきと呼んだプレーヤーは、入札者にダイスを与えなければなりません彼らが少なくとも彼が入札した数と同じ数であれば、正確な数である必要はありません）
• あなたがサイコロを使い果たすと、あなたは失う
• 最後のプレイヤーが勝ちます

例えば：

プレイヤー1には1,1,2,4,6があります
プレイヤー2には1,2,2,3,5があります
プレイヤー3には1,3,3,4,6があります
プレイヤー1：3つのシックス。
プレイヤー2：4 2。
プレイヤー3：フォースリー。
プレイヤー1：5 2。
プレイヤー2：6 2。
プレイヤー3：6人のスリー。
プレーヤー1：6人の4人。
プレイヤー2：うそつき！
彼らはサイコロを公開し、（サイコロがワイルドであるため）サイコロとフォーを数えます。
実際には、正確に6つのフォーがあります。
したがって、プレイヤー2はプレイヤー1にダイスを与えます。
彼らはリロールし、プレイヤー1は次のラウンドを開始します。

このゲームをプレイするにはボットを作成する必要があります。次の抽象Javaクラスを実装する必要があります。

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

• 入札方法を実装する必要があります
  • 最初の引数はターン順でのボットの現在位置、2番目は各プレイヤー（自分を含む）が現在持っているサイコロの数を示す配列、3番目は自分のサイコロに現在表示されている値を示す配列、4番目は現在のラウンドの開始以降に行われたすべての入札の配列-ラウンドの最初の入札を行っている場合、長さ0になります
  • 出力は、「number face」形式の文字列、または「Liar！」文字列のいずれかである必要があります。前の入札者を嘘つきと呼ぶ。
  • 出力が不正にフォーマットされている場合、排除されます。
• toStringメソッドをオーバーライドできますが、必須ではありません。ただし、コントローラーの出力の可読性を妨げるような方法で編集することはできません。
• コントローラーの他のパブリックメソッドを呼び出すことは許可されていますが、メインメソッドを呼び出すことは許可されていません。
• ボット自身の名前のプレフィックスが付いた実行ディレクトリ内のファイルのみを読み取り、編集できます
• 他のソースからの入力を許可されていません
• インスタンス変数は各新しいゲームの開始時にリセットされますが、静的変数はリセットされません。

得点

• ボットが追加されるたびに（3つ以上のボットが送信されるとすぐに）、それぞれ3〜5人のプレイヤーで構成される1,000のゲームのセットがシミュレートされ、コントローラーソースに表示されたスコア（任意のゲームで、各ターンの開始時に1、ダイスを獲得するたびに10、獲得した場合は1,000のボーナスを獲得します。各ゲームで5,000ターン（ラウンドではなく）の制限を強制します。
• ボットは、最新のゲームセットのスコアによってスコアリングされます。プラスでない場合、投票スコアの10倍。（後者はスコアに大きな影響を与える可能性は低いです）

コントローラのソースはここにあります。

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

誰も

他のプレイヤーからサイコロを推測しようとします。どうすればいいかわからない場合は、他のボットを嘘つきに呼び出します。

編集：誰も永遠に入札しない問題を修正し、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、二項分布に基づいて悪意のある決定を行うボット：編集：確率計算の愚かな誤りを修正し、次のBidderおよび前のBidderを考慮します。

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

}

自身の推定累積二項分布と、必要なサイコロが存在する前の入札者と次の入札者のチャンスに基づいて、ライアをブラフするかコールするかを決定しようとします。

基本的に、前の入札者が嘘つきである可能性が非常に高い場合、またはそれと次の入札者の両方が嘘をついている可能性が高いと感じた場合に、嘘つきを呼び出します。

ストレートシューター

彼はそれをまっすぐにプレーし、ブラフしません。彼は他の人もそうだと思うほど素朴なので、入札がプレイ中のサイコロの総数を超えない限り、嘘つきとは呼ばない（入札と一致しない自分のサイコロを差し引く）。

各ダイスの正確な予想数よりも少し控えめにするために、彼は自分のワイルドをカウントしませんが、他のワイルドが均一に分布していると仮定します。現在の4人のプレーヤーでは、彼またはMostlyHonestAbeが毎回最初に出て、かなり近いスコアを出しました。

最低入札価格はであると仮定しています2 2。1つのダイ（または入札）の入札が許可されている場合、その変更を行えるようにお知らせください。

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

安倍は、残りの敵が死ぬことについて保守的な推測を行い、それから彼が現在の入札を打ち負かすのに十分なサイコロがあると思わなくなるまで正直なままです。この時点で、彼は一度ブラフし、次に嘘つきを呼びます。

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

ドクターハウス

みんな嘘！

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

フィデリオ

このボットは、彼の最も頻繁な値だけが彼を勝利に導くことを知っているので、彼はそれに固執します。彼は全員のサイコロの一部が彼と同じであると仮定し、誰かがその部分より多く入札した場合、彼は嘘つきであると仮定します。

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

彼が良い仕事をしてくれることを願っています:)。

統計学者

エース以外の数字を持っている可能性は1/3です。ある人は、あなたのサイコロをチェックせず、オッズを知っているだけでこのゲームに勝つことができると言ったことがあります。編集：それは高すぎる入札だった。しかし、それはスコアをあまり改善しません。

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

不条理なボット

できない場合を除き、サイコロはすべて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";
    }
}

海賊

コントローラーのテスト中にいくつかの簡単なボットを作成しましたが、これが本当に良い唯一のボットです。

後で改善される可能性があります。

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