Liar's Dice ist ein ziemlich einfaches Würfelspiel. Ich habe einige verschiedene Variationen der Regeln gesehen, aber hier ist die Version, mit der ich am vertrautesten bin:

• Jeder Spieler beginnt mit 5W6
• Außer wenn die Würfel am Ende einer Runde gezählt werden, kann jeder Spieler seine eigenen Würfel sehen, jedoch nicht die eines Gegners
• Zu Beginn einer beliebigen Runde würfeln alle Spieler mit den Würfeln, die sie gerade haben
• Dann ein Spieler (normalerweise ist dies entweder der Gewinner der vorherigen Runde ODER der Spieler links von dem Spieler, der das letzte Mal gestartet ist. Wir werden den ersteren für diese KotH verwenden. Ein zufälliger Spieler beginnt die erste Runde.) errät, wie viele von einer bestimmten Zahl auf dem Tisch sind (ONES ARE WILD)
• Das Bieten geht nach rechts weiter und wird jedes Mal höher (zum Beispiel: 3 Fünfer, 3 Sechsen und 4 Zweier sind alle höher als 3 Vierer, aber 3 Dreier sind nicht; 4 ist ebenfalls höher, aber das Bieten auf einen bringt Sie wahrscheinlich zu einem Nachteil); bis ein Spieler den vorhergehenden Spieler als Lügner bezeichnet
• Zu diesem Zeitpunkt decken alle Spieler ihre Würfel auf und zählen die Nummer des letzten auf den Tisch gebotenen Gebots
• Wenn die Summe niedriger als das Gebot ist, muss der Spieler, der das Gebot abgegeben hat, dem Spieler, der sie als Lügner bezeichnet hat, einen Würfel geben, ansonsten muss der Spieler, der den Bieter als Lügner bezeichnet hat, dem Bieter einen Würfel geben (damit der Bieter gewinnt) Wenn es mindestens so viele von dieser Zahl gibt, wie er geboten hat, muss es nicht die genaue Zahl sein.
• Wenn Sie keine Würfel mehr haben, verlieren Sie
• Der letzte Spieler gewinnt

Beispielsweise:

Spieler eins hat 1,1,2,4,6
Spieler zwei hat 1,2,2,3,5
Spieler drei hat 1,3,3,4,6
Spieler eins: drei Sechser.
Spieler zwei: vier Zweien.
Spieler drei: vier Dreien.
Spieler eins: fünf Zweien.
Spieler zwei: sechs Zweien.
Spieler drei: sechs Dreien.
Spieler eins: sechs Vierer.
Spieler zwei: Lügner!
Sie decken ihre Würfel auf und zählen die (weil die wild sind) und die Vierer.
Es stellt sich heraus, dass es tatsächlich genau sechs Vierer gibt.
Spieler zwei gibt Spieler eins einen Würfel.
Sie wiederholen und Spieler eins beginnt die nächste Runde.

Sie müssen einen Bot schreiben, um dieses Spiel zu spielen. Es muss die folgende abstrakte Java-Klasse implementieren:

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

• Sie müssen die Bid-Methode implementieren
  • Das erste Argument ist die aktuelle Position Ihres Bots in der Zugreihenfolge, das zweite ist ein Array, das angibt, wie viele Würfel jeder Spieler (einschließlich Sie selbst) aktuell hat, das dritte ist ein Array, das die aktuell auf Ihren eigenen Würfeln angezeigten Werte anzeigt, und das vierte ist Ein Array aller Gebote, die seit Beginn der aktuellen Runde abgegeben wurden, hat die Länge 0, wenn Sie das erste Gebot der Runde abgeben
  • Die Ausgabe sollte entweder eine Zeichenfolge der Form "Zahlengesicht" oder die Zeichenfolge "Lügner!" den vorherigen Bieter als Lügner bezeichnen.
  • Wenn Ihre Ausgabe illegal formatiert ist, werden Sie eliminiert.
• Sie können die toString-Methode überschreiben, müssen dies jedoch nicht. Sie dürfen sie jedoch nicht in einer Weise bearbeiten, die die Lesbarkeit der Controller-Ausgabe beeinträchtigt.
• Sie dürfen andere öffentliche Methoden des Controllers aufrufen, jedoch nicht dessen Hauptmethode.
• Sie können nur Dateien im laufenden Verzeichnis lesen und bearbeiten, denen der Name Ihres Bots vorangestellt ist
• Es ist Ihnen nicht gestattet, Eingaben von anderen Quellen zu übernehmen
• Instanzvariablen werden zu Beginn jedes neuen Spiels zurückgesetzt, statische Variablen jedoch nicht.

Wertung

• Jedes Mal, wenn ein Bot hinzugefügt wird (sobald drei oder mehr Bots eingereicht wurden), wird ein Satz von 1.000 Spielen mit jeweils 3-5 Spielern simuliert Holen Sie sich zu Beginn jedes Spielzugs 1, jedes Mal 10, wenn Sie einen Würfel erobern, und 1.000 Bonus, wenn Sie gewinnen. Erzwingen eines Limits von 5.000 TURNS (keine Runden) pro Spiel.
• Ihr Bot wird nach seiner Punktzahl aus der letzten Reihe von Spielen gewertet. plus das Zehnfache der Stimmenzahl, wenn nicht negativ. (Letzteres wird wahrscheinlich keinen signifikanten Einfluss auf die Punktzahl haben.)

Die Controller-Quelle finden Sie hier.

Stand vom 19.06.2015:

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

Niemand

Versucht, die Würfel anderer Spieler zu erraten. Ruft andere Bots als Lügner an, wenn sie nicht wissen, was sie tun sollen.

Bearbeiten: Es wurde ein Problem behoben, durch das niemand für immer bieten und niemals Lügner anrufen konnte.

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, der Bot, der basierend auf Binomialverteilungen schlechte Entscheidungen trifft: Bearbeiten: Ein dummer Fehler in den Wahrscheinlichkeitsberechnungen wurde nun sowohl den nächsten als auch den vorherigen Bieter berücksichtigt.

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

}

Anhand der geschätzten kumulativen Binomialverteilungen für sich selbst und der Chancen der vorherigen und nächsten Bieter, die benötigten Würfel zu haben, wird versucht zu bestimmen, ob sie bluffen oder Lügner nennen sollen.

Grundsätzlich nennt es Lügner, wenn der vorherige Bieter sehr wahrscheinlich ein Lügner ist oder wenn es das Gefühl hat, dass sowohl er als auch der nächste Bieter mit größerer Wahrscheinlichkeit lügen als nicht.

Straight Shooter

Er spielt es direkt und blufft nicht. Er ist auch naiv genug, um zu glauben, dass es auch andere tun, und ruft daher niemals einen Lügner an, es sei denn, das Gebot überschreitet die Gesamtzahl der Würfel im Spiel (abzüglich seiner eigenen Würfel, die dem Gebot nicht entsprechen).

Um ein bisschen konservativer zu sein als die genaue erwartete Anzahl für jeden Würfel, zählt er seine eigenen Wilds nicht, sondern geht davon aus, dass andere eine einheitliche Verteilung haben. Bei den aktuellen vier Spielern landeten entweder er oder MostlyHonestAbe jedes Mal auf dem ersten Platz und erzielten ziemlich gute Ergebnisse.

Ich gehe davon aus, dass das Mindestgebot ist 2 2. Wenn ein Gebot für einen Würfel (oder ein Gebot für einen) zulässig ist, lassen Sie es mich wissen, damit ich diese Änderung vornehmen kann.

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 lässt konservative Vermutungen über den Rest des Gegners sterben und bleibt dann ehrlich, bis er glaubt, dass es nicht genug Würfel gibt, um das aktuelle Gebot zu übertreffen. Zu diesem Zeitpunkt blufft er einmal und ruft dann beim nächsten Mal den Lügner an.

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

Jeder lügt!

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

Fidelio

Dieser Bot weiß, dass nur sein häufigster Wert ihn zum Sieg führt, also bleibt er dabei. Er geht davon aus, dass ein Teil der Würfel eines jeden gleich ist wie seiner. Wenn jemand mehr als diesen Teil bietet, geht er davon aus, dass er ein Lügner ist.

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

Ich hoffe er leistet gute Arbeit :).

Statistiker

Sie haben eine Chance von 1/3, eine andere Zahl als Asse zu haben. Ein Typ hat mir einmal gesagt, dass Sie dieses Spiel gewinnen können, wenn Sie Ihre Würfel nicht überprüfen und nur die Gewinnchancen kennen. EDIT: Es wurde zu hoch geboten. Aber es verbessert die Punktzahl nicht sehr.

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

Absurder Bot

Stellt die Behauptung auf, dass alle Würfel 6 sind, sofern dies nicht möglich ist. Wenn der Bot das nicht kann, bedeutet dies, dass dies eine unmögliche oder nahezu unmögliche Situation ist. Aus diesem Grund nennt es Lügner. Ich bin gespannt, wie effektiv dieser Bot sein wird.

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

Der Pirat

Ich habe ein paar einfache Bots gemacht, während ich den Controller getestet habe, und dies ist der einzige, der wirklich gut ist.

Wird wahrscheinlich später verbessert.

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