Yalancı Zar , oldukça basit bir zar oyunudur. Kuralların birkaç farklı varyasyonunu gördüm, ancak burada en aşina olduğum sürüm:

• Her oyuncu 5d6 ile başlar
• Bir raundun sonundaki zarları okuduğunuzda, her oyuncu kendi zarlarını görebilir, ancak rakiplerinin hiçbirini göremez.
• Herhangi bir raundun başında, tüm oyuncular şu anda sahip oldukları zarları atarlar
• Daha sonra, bir oyuncu (genellikle bu, önceki turun galibidir VEYA son kez başlayan oyuncunun solundaki oyuncudur; bu turda ilk defa başlayan bir rastgele oyuncuyla bu KotH için eskiyi kullanacağız) Tabloda belirli bir sayının kaç tanesinin bulunduğunu tahmin eder (ONES AILD WILD)
• Teklif verme her zaman daha yüksek olacak şekilde sağa devam eder (örneğin; 3 beş, 3 altı ve 4 iki tanesi 3 dörtten daha yüksektir, ancak 3 üçlük değildir; 4 adet daha yüksektir, ancak bunlara teklif vermek muhtemelen size bir teklif verir.) dezavantaj); Herhangi bir oyuncu, onlardan önce bir yalancıyı çağırana kadar
• Bu noktada, tüm oyuncular zarlarını ortaya koyuyor ve masadaki son sayı teklifinin sayısını toplam olarak sayıyor
• Toplam teklifin altındaysa, teklifi veren oyuncu, onları yalancı çağıran oyuncuya bir kalıp vermelidir, aksi takdirde, teklifi veren kişiyi yalancı çağıran oyuncu, teklif sahibine bir kalıp vermelidir (teklif sahibi kazanır. eğer en azından teklif ettiği sayıdan daha fazlaysa, kesin sayıya gerek yoktur)
• Zar bittiğinde kaybedersin
• Son kalan oyuncu kazanır

Örneğin:

Oyuncu bir 1,1,2,4,6
İki oyuncu 1,2,2,3,5
Üç oyuncu 1,3,3,4,6
Oyuncu bir: üç altı.
İkinci oyuncu: dört ikilik.
Üçüncü oyuncu: dört üçlü.
Oyuncu bir: beş iki.
İkinci oyuncu: altı iki.
Üçüncü oyuncu: altı üçlü.
Birinci oyuncu: altı ayak.
İkinci oyuncu: Yalancı!
Zarlarını açığa çıkarırlar ve onlardan (çünkü onlar vahşidir) ve dörtten sayarlar.
Aslında, tam olarak dört ayak olduğu ortaya çıktı.
Yani ikinci oyuncu, birinci oyuncuya ölür.
Yeniden koşarlar ve oyuncu bir sonraki tura başlar.

Bu oyunu oynamak için bir bot yazmalısın. Aşağıdaki soyut java sınıfını uygulamalıdır:

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

• Teklif yöntemini uygulamalısınız
  • İlk argüman, botunuzun dönüş sırasındaki şu anki pozisyonudur, ikincisi, her oyuncunun (kendiniz dahil) şu anda kaç tane zar olduğunu gösteren bir dizidir, üçüncüsü, şu anda kendi zarlarınızda gösterilen değerleri gösteren bir dizidir ve dördüncü geçerli turun başlangıcından bu yana yapılan tüm tekliflerin bir dizisi - turun ilk teklifini yaparsanız 0 uzunluğuna sahip olacak
  • Çıktı ya "sayı yüzü" biçiminde ya da "Yalancı!" Dizgisi olmalıdır. önceki teklifi verene yalancı çağırmak için.
  • Çıktınız yasadışı olarak biçimlendirilmişse, yok edilirsiniz.
• ToString yöntemini geçersiz kılabilirsiniz, ancak buna gerek yoktur. Ancak, kontrol cihazının çıktısının okunabilirliğine müdahale eden herhangi bir şekilde düzenleyemezsiniz.
• Denetleyicinin diğer genel yöntemlerini çağırmanıza izin verilir, ancak ana yöntemi kullanamazsınız .
• Yalnızca çalışan dizindeki ve botunuzun kendi adıyla önceden belirlenmiş dosyaları okuyabilir ve düzenleyebilirsiniz.
• Başka bir kaynaktan girdi almanıza izin verilmiyor
• Örnek değişkenler her yeni oyunun başında sıfırlanır, ancak statik değişkenler değildir.

puanlama

• Her biri 3-5 oyuncudan oluşan 1000 oyundan oluşan bir set, her bot eklenişinde (üç veya daha fazla bot gönderildiğinde) kontrolör kaynağında gösterildiği gibi puanlandırılır (herhangi bir oyunda, Her bir dönüşünüzün başında 1, her bir kalıp yakaladığınızda 10 ve kazanırsanız 1.000 bonus kazanın); Her oyunda 5.000 TUR limit (tur değil) uygulanır.
• Botunuz en son oyun grubundan aldığı skorla puanlanır; Ayrıca, olumsuz değilse, oy puanının on katıdır. (İkincisi puan üzerinde önemli bir etkiye sahip olması muhtemel değildir)

Denetleyici kaynağı burada bulunabilir .

2015-06-19 tarihi itibariyle puanlar:

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

Kimse

Diğer oyunculardan gelen zarları tahmin etmeye çalışır. Ne yapacağını bilmiyorsa diğer botlara yalancıları çağırır.

Düzenleme: Hiç kimsenin sonsuza kadar teklif vermeyeceği, asla yalancı aramadığı bir sorun düzeltildi.

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, binom dağılımlarına dayanarak kötü kararlar veren bot: Düzenleme: Olasılık hesaplamalarında aptalca bir hata düzeltildi, şimdi bir önceki Teklifin yanı sıra bir sonraki Teklif Sahibi için de geçerli.

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

}

Kendisi için tahmini kümülatif binom dağılımlarına ve önceki ve sonraki teklif sahiplerinin ihtiyaç duydukları zarların mevcut olma şansına dayanarak blöf yapıp yapmamaya karar vermeleri gerektiğini belirlemeye çalışır.

Temel olarak, bir önceki Teklif Sahibinin bir Yalancı olma olasılığı çok yüksekse veya hem Teklifin hem de bir sonraki İsteklinin yalan söylememekten daha muhtemel olduğunu hissediyorsa, Yalancı adını verir.

Düz Atıcı

Düz oynuyor ve blöf yapmıyor. Ayrıca, diğerlerinin de yaptığını düşünecek kadar naif, bu yüzden teklif oyundaki toplam zar sayısını geçmediği sürece asla yalancı demiyor (eksi teklifine uymayan kendi zarını kullanmıyor).

Her bir kalıp için beklenen tam sayıdan biraz daha muhafazakâr olmak için, kendi sömürgelerini saymaz, ancak diğerlerinin eşit dağılıma sahip olduğunu varsayar. Şu anki dört oyuncu ile, o ya da MostlyHonestAbe, her seferinde ilk sıralarda oldukça yakın puanlarla geldi.

Minimum teklifin olduğunu farz ediyorum 2 2. Bir ölüme (veya teklif verenlere) teklif verilirse, bu değişikliği yapabilmem için bana bildirin.

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, diğer rakiplerin öldüğü hakkında muhafazakar tahminlerde bulunur ve ardından mevcut teklifi yenecek kadar zar olmadığını düşünene kadar dürüst kalır. Bu noktada bir kez blöf yapar, bir dahaki sefere yalancı çağırır.

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.

Herkes yalan söyler!

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

Fidelio

Bu bot, sadece en fazla değerinin kendisini zafere taşıyacağını biliyor, o yüzden buna sadık kalıyor. Herkesin zarının bir kısmı olduğunu varsayar, onun bir kısmı daha fazlasını teklif ederse, yalancı olduğunu varsayar.

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

Umarım iyi işler yapar :).

İstatistikçi

As dışında bir sayıya 1/3 sahip olma şansın var. Biri bir keresinde bana dicesini kontrol etmemenin ve şansı bilmenin juste'nin bu oyunu kazanmanı sağlayabileceğini söylemişti. EDIT: Çok yüksek teklif veriyordu. Ancak skoru pek geliştirmiyor.

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

Saçma Bot

Tüm zarların yapamadığı sürece 6's olduğu iddiasını ortaya çıkarır. Bot bunu yapamazsa, bunun imkansız bir durum olduğu ya da neredeyse imkansız olduğu bir durum olduğu anlamına gelir. Bu nedenle yalancı diyor. Bu botun ne kadar etkili olacağını merak ediyorum.

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

Korsan

Kontrol cihazını test ederken birkaç basit bot yaptım ve bu gerçekten iyi olan tek şey.

Muhtemelen daha sonra geliştirilecektir.

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