거짓말 쟁이의 주사위 는 매우 간단한 주사위 게임입니다. 몇 가지 다른 규칙을 보았지만 가장 익숙한 버전은 다음과 같습니다.

• 각 플레이어는 5d6으로 시작합니다
• 라운드가 끝날 때 주사위를 계산할 때를 제외하고, 각 플레이어는 자신의 주사위를 볼 수 있지만 상대방의 주사위는 볼 수 없습니다
• 주어진 라운드가 시작될 때 모든 플레이어는 현재 가지고있는 주사위를 굴립니다.
• 그런 다음 한 명의 플레이어 (일반적으로 이것은 이전 라운드의 승자이거나 마지막으로 시작한 플레이어의 왼쪽에있는 플레이어입니다. 우리는이 KotH에 대해 이전 플레이어를 사용합니다. 임의의 플레이어가 첫 번째 라운드를 시작 함) 테이블에 몇 개의 특정 숫자가 있는지 추측합니다 (ONES ARE WILD)
• 매번 더 높게 올라가는 입찰은 계속 오른쪽으로 진행됩니다 (예 : 3 5, 3 6, 4 2는 모두 3 4보다 높지만 3 3은 그렇지 않습니다. 4 1도 높지만 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 : 4 3
플레이어 1 : 5 2
선수 2 : 여섯 둘.
3 번 선수 : 6시 3 분.
선수 1 : 육십.
두 번째 선수 : 거짓말 쟁이!
그들은 자신의 주사위를 공개하고 하나 (사나운 것이기 때문에)와 4를 세어줍니다.
실제로 정확히 6-4가 있음이 밝혀졌습니다.
따라서 2 번 선수는 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);
}

• 입찰 방법을 구현해야합니다
  • 첫 번째 인수는 턴 순서에서 봇의 현재 위치이고, 두 번째 인수는 현재 각 플레이어 (자신 포함)의 주사위 수를 나타내는 배열이고, 세 번째는 현재 자신의 주사위에 표시된 값을 보여주는 배열입니다. 현재 라운드가 시작된 이후에 이루어진 모든 입찰 배열-라운드의 첫 번째 입찰을하는 경우 길이는 0입니다.
  • 출력은 "number face"형식의 문자열이거나 "Liar!"문자열이어야합니다. 이전 입찰자를 거짓말 쟁이라고 부릅니다.
  • 출력 형식이 잘못되면 제거됩니다.
• toString 메소드를 대체 할 수 있지만 필수는 아닙니다. 그러나 컨트롤러 출력의 가독성을 방해하는 방식으로 편집 할 수 없습니다.
• 컨트롤러의 다른 공용 메소드는 호출 할 수 있지만 기본 메소드는 호출 할 수 없습니다 .
• 봇 자신의 접두사가 붙은 실행중인 디렉토리의 파일 만 읽고 편집 할 수 있습니다
• 다른 출처에서 정보를 입수 할 수 없습니다
• 인스턴스 변수는 새로운 게임이 시작될 때마다 재설정되지만 정적 변수는 재설정되지 않습니다.

채점

• 봇이 추가 될 때마다 (3 개 이상의 봇이 제출 되 자마자) 1,000 개의 게임 세트가 시뮬레이션되며 컨트롤러 소스 (어떤 게임에서든 각 턴이 시작될 때마다 1, 주사위를 capture 때마다 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

아무도

다른 플레이어의 주사위를 추측하려고합니다. 무엇을 해야할지 모르는 경우 다른 봇을 거짓말 쟁이에게 부릅니다.

편집 : 아무도 입찰하지 않고 영원히 거짓말을하지 않는 문제가 수정되었습니다.

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 : 편집 : 확률 계산에서 바보 같은 실수를 수정하여 이제 다음 입찰자와 이전 입찰을 설명합니다.

    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. 하나의 입찰 (또는 입찰 입찰)에 대한 입찰이 허용되는 경우, 그 변경을 할 수 있도록 알려주십시오.

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

대체로 정직한

Abe는 나머지 상대방의 사망에 대해 보수적 인 추측을 한 다음 현재 입찰을 이길만한 주사위가 충분하다고 생각하지 않을 때까지 정직하게 유지합니다. 이 시점에서 그는 한 번 허풍을 치고 다음에 거짓말 쟁이를 부릅니다.

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