König des Hügels - Würfel des Lügners

22

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
SuperJedi224
quelle
1
Sie sollten klarstellen, dass die Ausgabe "2 3" und nicht "zwei Dreien" laut Beispiel sein sollte. Gibt es eine Möglichkeit im Controller, ein einzelnes Match zu sehen?
Cain,
Nicht in der offiziellen Version, aber ich werde eine alternative Version veröffentlichen, mit der Sie dies tun können.
SuperJedi224
@ Geobits: Wenn du willst. Es wird dich ein bisschen benachteiligen, wenn dich jemand anruft.
SuperJedi224
1
Ich gehe davon aus, dass die Indizes der Arrays die "IDs" der Spieler sind, so dass diceEachPlayerHas[yourId]= Ihre Würfel zählen und bids[yourId]Ihr erstes Gebot ist (oder null, wenn Sie zum ersten Mal an der Reihe sind). Ist das korrekt?
Nicht dass Charles
1
Ich habe Spiele gesehen, bei denen einige Einsendungen mehr Spiele spielen als andere (Niemand: 414 Spiele, Straight Shooter: 409 Spiele). Das ist nicht fair, können Sie das bitte beheben?
CommonGuy

Antworten:

6

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!";
    }
}
CommonGuy
quelle
Ihre letzten Updates scheinen wirklich geholfen zu haben.
SuperJedi224,
6

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.

InactionPotential
quelle
Mit diesen Änderungen scheint Badnomial im Vergleich zu den anderen Bots tatsächlich aus der Ferne kompetent zu sein.
InactionPotential
5

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;
    }
}
Geobits
quelle
This und MostlyHonestAbe zögern beide, zu lügen oder Lügner zu nennen. Es gibt einige Spiele, die bis zu 2000 Runden dauern, wenn ich sie teste, haha. : P
Cain
Das gleiche gilt für mich. Das ist aber in Ordnung, denn jede Runde ist ein zusätzlicher Punkt für das Endergebnis. Wenn ich in den letzten 2000
Runden
Ich musste mir nur noch einmal die Bewertungsregeln ansehen. Ganz neues Spiel XD
Cain
Ja, mit dieser Wertung scheint es die optimale Strategie zu sein, so konservativ wie möglich zu sein und nur Punkte zu sammeln. Vielleicht gibt es etwas Besseres, aber ich kann es nicht sehen.
Geobits
1
Ich bin mir nicht sicher , ob es einen großen Unterschied machen würde. Konservativ zu sein wäre immer noch ein Vorteil, nur weil Sie eine geringere Chance haben, einen Würfel zu verlieren. Der Grund, warum mehr Leute im wirklichen Leben nicht so spielen, ist, dass es nur langweilig ist, aber was ist Langeweile für einen Bot?
Geobits
4

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;
    }
}
Kain
quelle
1
Willst du mich veräppeln? Ich war weniger als fünf Minuten von der Veröffentlichung von HonestAbe entfernt . Jetzt muss ich mir einen neuen Namen
ausdenken
1
Ich kann kein Spiel mit Liar im Namen haben, ohne irgendwo einen Hinweis auf Abraham Lincoln zu haben.
Cain,
4

Dr. House

Jeder lügt!

public class DrHouse extends Player
{   
  public String bid(int yourId, int[] diceEachPlayerHas, int[] yourDice, String[] bids)
  {
    return "Liar!";
  }
}
Gus314
quelle
1
Ich schlage vor, eine spezielle Logik hinzuzufügen, wenn Sie das erste Gebot der Runde haben.
SuperJedi224
4
@ SuperJedi224 Ich stelle mir vor, der Bot überlegt dann, ob der Controller ihm sagt, dass er an der Reihe ist, ein Lügner zu sein
Nathan Merrill,
Meinen Tag gemacht lol
Rohan Jhunjhunwala
2

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 :).

Katenkyo
quelle
Ich erhalte eine IndexOutOfBoundsException in Zeile 13. Denken Sie daran, dass Arrays in Java 0-indiziert sind.
SuperJedi224
Jetzt bekomme ich einen am anderen Ende in Zeile 19 für einen Index von -1. Es scheint, dass es versucht hat, das letzte Element aus einem leeren Array zu lesen. Sie sollten eine Prüfung dafür einschließen.
SuperJedi224
Die Überprüfung, ob (bids.length == 0) durchgeführt wurde, nachdem ich Gebote verwendet habe, wurde
korrigiert
Oh, ich hatte gerade eine andere mögliche Lösung vorgeschlagen, aber dies wird wahrscheinlich auch funktionieren.
SuperJedi224
Ah, also wird diese vorgeschlagene Änderung nicht mehr benötigt?
mbomb007
2

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";
    }
}
Schlagen
quelle
1

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";
    }
}
Frederick
quelle
Wie effektiv: Seine Hauptfunktion scheint darin zu bestehen, Würfel an jeden Spieler zu verteilen, der ihm folgt: P
Geobits
@Geobits Ich habe den Code korrigiert. Dies ist, was passiert, wenn Sie versuchen, in eine Programmiersprache zu springen, die Sie noch nicht programmiert haben ...
Frederick
@Geobits Danke für die Hilfe. Ich denke, dass dies jetzt endlich richtig funktioniert. Macht es? (Java ist verwirrend)
Frederick
Ja, es läuft jetzt. Die Strategie ist jedoch wahnsinnig selbstmörderisch. Es zählt nur ~ 2% des nächstniedrigeren Spielers.
Geobits
@Geobits Ich habe nie versucht, es gegen die anderen Spieler laufen zu lassen. Hast du es gegen die anderen ausgetragen?
Frederick
1

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