King of the Hill - Pembohong Dadu


22

Liar's Dice adalah game dadu yang cukup sederhana. Saya telah melihat beberapa variasi peraturan yang berbeda, tetapi ini adalah versi yang paling saya kenal:

  • Setiap pemain mulai dengan 5d6
  • Kecuali ketika menghitung dadu pada akhir ronde, setiap pemain dapat melihat dadu mereka sendiri, tetapi tidak dari lawan mana pun
  • Di awal setiap babak, semua pemain melempar dadu apa pun yang mereka miliki saat ini
  • Kemudian, satu pemain (biasanya, ini adalah pemenang babak sebelumnya ATAU pemain di sebelah kiri pemain yang memulai terakhir kali; kami akan menggunakan yang pertama untuk KotH ini; dengan pemain acak memulai babak pertama) membuat perkiraan tentang berapa banyak nomor tertentu yang ada di atas meja (SATU-SATUNYA AKAN)
  • Penawaran terus ke kanan, naik lebih tinggi setiap kali (misalnya; 3 balita, 3 enam dan 4 dua semuanya lebih tinggi dari 3 merangkak, tetapi 3 bertiga tidak; 4 yang juga lebih tinggi tetapi penawaran yang mungkin akan menempatkan Anda pada kerugian); sampai pemain mana pun memanggil pemain yang mendahului mereka pembohong
  • Pada titik ini, semua pemain mengungkapkan dadu mereka dan menghitung jumlah tawaran nomor terakhir di atas meja sama sekali
  • Jika total lebih rendah dari tawaran, pemain yang mengajukan penawaran harus memberikan dadu kepada pemain yang menyebut mereka pembohong, jika tidak, pemain yang menyebut penawar pembohong harus memberikan dadu kepada penawar (sehingga penawar menang jika jumlah mereka setidaknya sebanyak yang dia tawarkan, tidak harus ada angka pastinya)
  • Saat Anda kehabisan dadu, Anda kalah
  • Posisi pemain terakhir menang

Sebagai contoh:

Pemain satu memiliki 1,1,2,4,6
Pemain dua memiliki 1,2,2,3,5
Pemain tiga memiliki 1,3,3,4,6
Pemain satu: tiga enam.
Pemain dua: empat berpasangan.
Pemain tiga: empat bertiga.
Pemain satu: lima berpasangan.
Pemain dua: enam berpasangan.
Pemain tiga: enam bertiga.
Pemain satu: enam merangkak.
Pemain dua: Pembohong!
Mereka mengungkapkan dadu mereka dan menghitung yang (karena yang liar) dan merangkak.
Ternyata ada, tepatnya, empat merangkak.
Jadi pemain dua memberi pemain satu mati.
Mereka memainkan kembali dan pemain satu memulai babak berikutnya.

Anda harus menulis bot untuk memainkan game ini. Itu harus mengimplementasikan kelas java abstrak berikut:

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);
}
  • Anda harus menerapkan metode penawaran
    • Argumen pertama adalah posisi bot Anda saat ini dalam urutan belokan, yang kedua adalah array yang menunjukkan berapa banyak dadu yang dimiliki setiap pemain (termasuk diri Anda) saat ini, yang ketiga adalah array yang menunjukkan nilai yang saat ini ditampilkan pada dadu Anda sendiri, dan yang keempat adalah sebuah array dari semua penawaran yang dibuat sejak awal putaran saat ini - akan memiliki panjang 0 jika Anda mengajukan tawaran pertama dari putaran tersebut
    • Outputnya harus berupa string dari bentuk "angka", atau string "Pembohong!" untuk menyebut penawar sebelumnya pembohong.
    • Jika output Anda diformat secara ilegal, Anda akan dihilangkan.
  • Anda dapat mengganti metode toString, tetapi tidak diharuskan untuk melakukannya. Namun, Anda tidak boleh mengeditnya dengan cara apa pun yang mengganggu keterbacaan output pengontrol.
  • Anda diizinkan memanggil metode publik lain dari pengontrol, tetapi bukan metode utamanya.
  • Anda dapat membaca dan mengedit hanya file di direktori yang sedang berjalan yang diawali dengan nama bot Anda sendiri
  • Anda tidak diizinkan mengambil input dari sumber lain mana pun
  • Variabel instan direset pada awal setiap game baru, tetapi variabel statis tidak.

Mencetak gol

  • Satu set 1.000 permainan, dengan 3-5 pemain di masing-masing, akan disimulasikan setiap kali bot ditambahkan (segera setelah tiga bot atau lebih telah diajukan), diberi skor seperti yang ditunjukkan dalam sumber pengontrol (dalam permainan tertentu, Anda dapatkan 1 di awal setiap giliran Anda, 10 setiap kali Anda menangkap mati, dan 1.000 bonus jika Anda menang); menegakkan batas 5.000 TURNS (bukan putaran) setiap game.
  • Bot Anda akan dinilai berdasarkan skornya dari set game terbaru; ditambah sepuluh kali skor suaranya, jika tidak negatif. (Yang terakhir tidak mungkin memiliki efek signifikan pada skor)

Sumber pengontrol dapat ditemukan di sini.

Skor per 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

1
Anda harus mengklarifikasi bahwa output harus "2 3" dan bukan "dua bertiga" seperti contoh yang Anda tunjukkan. Juga, apakah ada cara di controller untuk menonton pertandingan tunggal?
Kain

Tidak dalam versi resmi, tetapi saya akan memposting versi alternatif yang memungkinkan Anda melakukannya.
SuperJedi224

@ Getobits: Jika Anda mau. Ini akan membuat Anda sedikit dirugikan jika seseorang memanggil Anda.
SuperJedi224

1
Saya menganggap indeks array adalah "id" dari para pemain, sehingga diceEachPlayerHas[yourId]= jumlah dadu Anda, dan bids[yourId]merupakan tawaran pertama Anda (atau nol jika giliran pertama Anda). Apakah itu benar?
Bukan berarti Charles

1
Saya telah melihat game di mana beberapa pengiriman mengirimkan lebih banyak game daripada yang lain (Nobody: 414 games, Straight Shooter: 409 games). Ini tidak adil, bisakah Anda memperbaikinya?
CommonGuy

Jawaban:


6

Tak seorangpun

Mencoba menebak dadu dari pemain lain. Panggilan pembohong bot lain jika tidak tahu harus berbuat apa.

Sunting: Memperbaiki masalah di mana Tidak ada yang akan menawar selamanya, tidak pernah memanggil 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!";
    }
}

Kumpulan pembaruan terakhir Anda tampaknya sangat membantu.
SuperJedi224

6

Badnomial, bot yang membuat keputusan buruk berdasarkan distribusi binomial: Sunting: Memperbaiki kesalahan bodoh dalam perhitungan probabilitas, sekarang menyumbang pada Penawar berikutnya dan juga sebelumnya.

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

}

Ia mencoba untuk menentukan apakah ia harus menggertak atau memanggil Liar berdasarkan perkiraan distribusi binomial kumulatif untuk dirinya sendiri dan peluang bidder sebelumnya dan berikutnya untuk memiliki dadu yang mereka butuhkan.

Pada dasarnya, ini memanggil Liar jika Penawar sebelumnya sangat mungkin menjadi Pembohong atau jika merasa bahwa baik Penawar itu maupun Penawar berikutnya lebih cenderung berbohong daripada tidak.


Dengan perubahan-perubahan ini, Badnomial sebenarnya tampak jauh dari kompeten vs bot lainnya.
InactionPotential

5

Penembak lurus

Dia memainkannya lurus dan tidak menggertak. Dia juga cukup naif untuk berpikir bahwa orang lain juga begitu, jadi dia tidak pernah menyebut pembohong kecuali tawaran melampaui jumlah total dadu yang dimainkan (dikurangi dadu sendiri yang tidak cocok dengan tawaran).

Untuk menjadi sedikit lebih konservatif daripada jumlah yang diharapkan untuk setiap mati, ia tidak menghitung binatang buasnya sendiri, tetapi mengasumsikan orang lain memiliki distribusi yang seragam. Dengan empat pemain saat ini, dia atau MostlyHonestAbe tampil lebih dulu setiap kali, dengan skor yang cukup dekat.

Saya mengasumsikan tawaran minimum adalah 2 2. Jika tawaran satu mati (atau penawaran) diizinkan, beri tahu saya agar saya dapat melakukan perubahan itu.

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

Ini dan MostlyHonestAbe sangat ragu untuk berbohong atau memanggil pembohong, ada beberapa game yang akan berubah 2000 ketika saya menguji haha. : P
Cain

Sama dengan milik saya. Namun, tidak apa-apa, karena setiap belokan merupakan poin ekstra menuju skor akhir. Jika saya bertahan 2000 putaran dan tidak menang, itu lebih baik daripada menang setelah 100 dalam buku saya;)
Geobits

Saya hanya harus melihat peraturan penilaian lagi. Seluruh game XD baru
Kain

Ya, dengan skor ini sepertinya strategi optimal mungkin menjadi sekonservatif mungkin, dan hanya mengumpulkan poin. Mungkin ada sesuatu yang lebih baik, tetapi saya tidak bisa melihatnya.
Geobits

1
Saya tidak yakin itu akan membuat banyak perbedaan. Menjadi konservatif masih akan menjadi keuntungan, hanya karena Anda memiliki peluang lebih kecil untuk mati. Alasan lebih banyak orang tidak bermain seperti itu dalam kehidupan nyata adalah karena itu hanya membosankan, tetapi apa kebosanan pada bot?
Geobits

4

MostlyHonestAbe

Abe membuat tebakan konservatif tentang sisa lawan yang mati, dan kemudian tetap jujur ​​sampai dia tidak berpikir ada cukup dadu untuk mengalahkan tawaran saat ini. Pada titik ini dia menggertak sekali, lalu memanggil pembohong di waktu berikutnya.

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

1
Apakah kamu bercanda? Saya kurang dari lima menit dari memposting HonestAbe . Sekarang saya harus memikirkan nama baru: P
Geobits

1
Tidak dapat memiliki game dengan Liar dalam nama tanpa referensi Abraham Lincoln di suatu tempat.
Kain

4

Dr House

Semua orang berbohong!

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

1
Saya sarankan menambahkan logika khusus ketika Anda memiliki tawaran pertama putaran.
SuperJedi224

4
@ SuperJedi224 Saya membayangkan bahwa bot kemudian menganggap controller mengatakan kepadanya bahwa itu adalah gilirannya untuk menjadi pembohong
Nathan Merrill

Jadikan hari saya lol
Rohan Jhunjhunwala

2

Fidelio

Bot ini tahu bahwa hanya nilainya yang paling berulang yang akan membawanya ke kemenangan, jadi dia tetap menggunakannya. Dia menganggap ada sebagian dadu semua orang yang sama dengan miliknya, jika ada yang menawar lebih dari itu, dia menganggap dia pembohong.

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

Saya harap dia akan melakukan pekerjaan yang baik :).


Saya mendapatkan IndexOutOfBoundsException pada baris 13. Ingat bahwa array 0-diindeks di java.
SuperJedi224

Sekarang saya mendapatkan satu di ujung lain pada baris 19, dengan indeks -1. Tampaknya akan mencoba membaca elemen terakhir dari array kosong, Anda harus menyertakan tanda centang untuk itu.
SuperJedi224

Diperbaiki, periksa apakah (bids.length == 0) dilakukan setelah saya menggunakan tawaran ...
Katenkyo

Oh, saya baru saja mengusulkan solusi lain yang mungkin, tetapi ini mungkin akan berhasil juga.
SuperJedi224

Ah, jadi edit yang disarankan ini tidak lagi diperlukan?
mbomb007

2

Ahli statistik

Anda memiliki 1/3 peluang memiliki nomor selain ace. Seorang pria pernah mengatakan kepada saya bahwa tidak memeriksa dadu Anda dan hanya mengetahui kemungkinan dapat membuat Anda memenangkan permainan ini. EDIT: Itu penawaran terlalu tinggi. Tetapi itu tidak banyak meningkatkan skor.

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

1

Bot Absurd

Membuat klaim bahwa semua dadu adalah 6 kecuali jika tidak bisa. Jika bot tidak dapat melakukan itu, ini berarti bahwa ini adalah situasi yang tidak mungkin atau hampir tidak mungkin. Karena itu, ini disebut pembohong. Saya ingin tahu seberapa efektif bot ini nantinya.

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

Adapun seberapa efektif: Fungsi utamanya tampaknya memberikan dadu kepada pemain mana pun yang mengikutinya: P
Geobits

@ Geobits saya memperbaiki kode. Inilah yang terjadi ketika Anda mencoba untuk melompat ke bahasa pemrograman yang belum Anda program sebelumnya ...
frederick

@Geobits Terima kasih atas semua bantuannya. Saya pikir ini akhirnya berfungsi dengan baik sekarang. Melakukannya? (Java membingungkan)
frederick

Ya, itu berjalan sekarang. Namun, strateginya adalah bunuh diri. Hanya skor ~ 2% dari pemain terendah berikutnya.
Geobits

@ Geobits saya tidak pernah mencoba menjalankannya melawan pemain lain. Apakah Anda menjalankannya terhadap yang lain?
frederick

1

Bajak laut

Saya membuat beberapa bot sederhana saat menguji controller, dan ini adalah satu-satunya yang benar-benar bagus.

Kemungkinan akan diperbaiki nanti.

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!";
    }
}
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.