Liar's Dice est un jeu de dés assez simple. J'ai vu quelques variantes différentes des règles, mais voici la version que je connais le mieux:

• Chaque joueur commence avec 5d6
• Sauf lors du décompte des dés à la fin d'un tour, chaque joueur peut voir ses propres dés, mais pas ceux de n'importe quel adversaire
• Au début d'un tour donné, tous les joueurs lancent les dés qu'ils ont actuellement
• Ensuite, un joueur (généralement, c'est soit le vainqueur du tour précédent OU le joueur à gauche du joueur qui a commencé la dernière fois; nous utiliserons le premier pour ce KotH; avec un joueur aléatoire commençant le premier tour) fait une estimation du nombre d'un nombre particulier sur la table (ONES SONT SAUVAGES)
• Les enchères se poursuivent vers la droite, en augmentant à chaque fois (par exemple; 3 cinq, 3 six et 4 deux sont tous supérieurs à 3 fours, mais 3 trois ne le sont pas; 4 unités est également plus élevé mais enchérir sur celles-ci vous mettra probablement à un désavantage); jusqu'à ce qu'un joueur appelle le joueur qui les précède un menteur
• À ce stade, tous les joueurs révèlent leurs dés et comptent le numéro du dernier numéro mis sur la table.
• Si le total est inférieur à l'enchère, le joueur qui a fait l'enchère doit donner un dé au joueur qui les a appelés menteurs, sinon, le joueur qui a appelé l'enchérisseur un menteur doit donner un dé au soumissionnaire (pour que l'enchérisseur gagne si leur nombre est au moins égal à celui qu'il avait proposé, il n'est pas nécessaire qu'il y ait le nombre exact)
• Lorsque vous manquez de dés, vous perdez
• Le dernier joueur debout gagne

Par exemple:

Le joueur un a 1,1,2,4,6
Le joueur deux a 1,2,2,3,5
Le joueur trois a 1,3,3,4,6
Joueur un: trois six.
Joueur deux: quatre deux.
Joueur trois: quatre à trois.
Joueur un: cinq deux.
Joueur deux: six deux.
Joueur trois: six à trois.
Joueur un: six quatre.
Joueur deux: menteur!
Ils révèlent leurs dés et comptent ceux (parce que ceux sont sauvages) et les quatre.
Il s'avère qu'il y a, en fait, exactement six fours.
Donc, le joueur deux donne un dé au joueur un.
Ils relancent et le joueur n ° 1 commence le tour suivant.

Vous devez écrire un bot pour jouer à ce jeu. Il doit implémenter la classe java abstraite suivante:

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

• Vous devez implémenter la méthode d'enchères
  • Le premier argument est la position actuelle de votre bot dans l'ordre du tour, le second est un tableau montrant combien de dés chaque joueur (y compris vous-même) possède actuellement, le troisième est un tableau montrant les valeurs actuellement affichées sur vos propres dés, et le quatrième est un tableau de toutes les offres faites depuis le début du tour en cours - aura une longueur de 0 si vous faites la première enchère du tour
  • La sortie doit être soit une chaîne de la forme "numéro face", soit la chaîne "Liar!" appeler le soumissionnaire précédent un menteur.
  • Si votre sortie est formatée illégalement, vous serez éliminé.
• Vous pouvez remplacer la méthode toString, mais ce n'est pas obligatoire. Cependant, vous ne pouvez pas le modifier d'une manière qui interfère avec la lisibilité de la sortie du contrôleur.
• Vous êtes autorisé à appeler toute autre méthode publique du contrôleur, mais pas sa méthode principale.
• Vous pouvez lire et modifier uniquement les fichiers du répertoire en cours d'exécution préfixés par le nom de votre bot
• Vous n'êtes pas autorisé à prendre des informations provenant d'une autre source
• Les variables d'instance sont réinitialisées au début de chaque nouveau jeu, mais pas les variables statiques.

Notation

• Un jeu de 1000 jeux, avec 3-5 joueurs dans chacun, sera simulé chaque fois qu'un bot est ajouté (dès que trois bots ou plus ont été soumis), marqué comme indiqué dans la source du contrôleur (dans un jeu donné, vous obtenez 1 au début de chacun de vos tours, 10 à chaque fois que vous capturez un dé et 1 000 bonus si vous gagnez); appliquer une limite de 5 000 TOURS (pas de tours) à chaque partie.
• Votre bot sera marqué par son score de la dernière série de jeux; plus dix fois son score de vote, si non négatif. (Ce dernier est peu susceptible d'avoir un effet significatif sur le score)

La source du contrôleur peut être trouvée ici.

Scores au 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

Personne

Tente de deviner les dés des autres joueurs. Appelle les autres robots menteurs s'il ne sait pas quoi faire.

Edit: correction d'un problème où personne n'enchérissait pour toujours, n'appelant jamais 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, le bot qui prend de mauvaises décisions en se basant sur les distributions binomiales: Edit: correction d'une erreur stupide dans les calculs de probabilité, qui représente désormais le prochain enchérisseur ainsi que le précédent.

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

}

Il essaie de déterminer s'il doit bluffer ou appeler Liar en fonction des distributions binomiales cumulatives estimées pour lui-même et des chances des soumissionnaires précédent et suivant d'avoir leurs dés nécessaires présents.

Fondamentalement, il appelle menteur si le soumissionnaire précédent est très susceptible d'être un menteur ou s'il estime que lui et le prochain soumissionnaire mentent plus probablement qu'improbable.

Bon tireur

Il joue droit et ne bluffe pas. Il est également assez naïf pour penser que les autres le font aussi, donc il n'appelle jamais menteur à moins que l'enchère ne dépasse le nombre total de dés en jeu (moins ses propres dés qui ne correspondent pas à l'enchère).

Pour être un peu plus conservateur que le nombre exact prévu pour chaque dé, il ne compte pas ses propres jokers, mais suppose que les autres ont une distribution uniforme. Avec les quatre joueurs actuels, lui ou MostlyHonestAbe est venu en premier à chaque fois, avec des scores assez proches.

Je suppose que l'enchère minimale est 2 2. Si une enchère d'un dé (ou des enchères) est autorisée, faites-le moi savoir afin que je puisse faire ce changement.

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

Généralement honnête

Abe fait des suppositions conservatrices sur le reste des adversaires qui meurent, puis reste honnête jusqu'à ce qu'il ne pense pas qu'il y ait suffisamment de dés pour battre l'offre actuelle. À ce stade, il bluffe une fois, puis appelle menteur la prochaine fois.

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

Tout le monde ment!

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

Fidelio

Ce bot sait que seule sa valeur la plus récurrente le mènera à la victoire, alors il s'y tient. Il suppose qu'il y a une portion des dés de tout le monde qui est la même que la sienne, si quelqu'un offre plus que cette portion, il suppose qu'il est un menteur.

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

J'espère qu'il fera du bon travail :).

Statisticien

Vous avez 1/3 de chance d'avoir un nombre autre que des as. Un gars m'a dit une fois que ne pas vérifier vos dés et simplement connaître les cotes pouvait vous faire gagner ce match. EDIT: L'enchère était trop élevée. Mais cela n'améliore pas beaucoup le score.

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

Absurde Bot

Affirme que tous les dés sont des 6 à moins que ce ne soit pas possible. Si le bot ne peut pas faire cela, cela signifie que c'est une situation impossible ou presque impossible. Pour cette raison, il appelle menteur. Je suis curieux de savoir à quel point ce bot sera efficace.

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

Le pirate

J'ai fait quelques bots simples en testant le contrôleur, et c'est le seul qui soit vraiment bon.

Sera probablement amélioré plus tard.

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