हिल के राजा - लिआर्स पासा

22

Liar का पासा एक काफी सरल पासा खेल है। मैंने नियमों के कुछ भिन्न रूप देखे हैं, लेकिन यहाँ वह संस्करण है जिससे मैं सबसे अधिक परिचित हूँ:

  • प्रत्येक खिलाड़ी 5d6 से शुरू होता है
  • एक दौर के अंत में पासा निकालने के अलावा, प्रत्येक खिलाड़ी अपना पासा देख सकता है, लेकिन किसी भी प्रतिद्वंद्वी का नहीं।
  • किसी भी दौर की शुरुआत में, सभी खिलाड़ियों के पास जो भी पासा होता है, उसे रोल करते हैं
  • फिर, एक खिलाड़ी (आमतौर पर, यह या तो पिछले दौर का विजेता होता है या पिछली बार शुरू होने वाले खिलाड़ी के बाईं ओर का खिलाड़ी; हम इस कोट के लिए पूर्व का उपयोग करेंगे; एक यादृच्छिक खिलाड़ी के साथ पहले दौर की शुरुआत करेंगे; एक विशेष संख्या में तालिका में कितने हैं ( इसके बारे में अनुमान लगाता है )
  • बोली लगाना सही जारी है, हर बार अधिक हो रहा है (उदाहरण के लिए; 3 फाइव, 3 छक्के और 4 जुड़वां, सभी 3 चौकों से अधिक हैं, लेकिन 3 थ्रेड्स नहीं हैं; 4 वाले भी अधिक हैं, लेकिन उन पर बोली लगाने से शायद आपको लग जाएगा। हानि); जब तक कोई भी खिलाड़ी खिलाड़ी को कॉल नहीं करता, तब तक वह उन्हें झूठा साबित नहीं कर सकता
  • इस बिंदु पर, सभी खिलाड़ी अपना पासा प्रकट करते हैं और तालिका पर अंतिम संख्या बोली की संख्या को पूरी तरह से गिनते हैं
  • यदि कुल बोली से कम है, तो बोली लगाने वाले खिलाड़ी को उस खिलाड़ी को मरना होगा, जो उन्हें झूठा कहता है, अन्यथा, बोली लगाने वाले को झूठा कहने वाले खिलाड़ी को बोली लगाने वाले को मरना होगा (इसलिए बोली लगाने वाला जीतता है यदि उनकी संख्या कम से कम उतनी है जितनी उन्होंने बोली लगाई थी, तो सटीक संख्या नहीं होनी चाहिए)
  • जब आप पासे से बाहर निकलते हैं, तो आप हार जाते हैं
  • आखिरी खिलाड़ी खड़े जीतता है

उदाहरण के लिए:

प्लेयर एक में 1,1,2,4,6 है
प्लेयर दो में 1,2,2,3,5 हैं
प्लेयर तीन में 1,3,3,4,6 हैं
खिलाड़ी एक: तीन छक्के।
खिलाड़ी दो: चार जुड़वां।
खिलाड़ी तीन: चार तेरह।
खिलाड़ी एक: पांच जुड़वां।
खिलाड़ी दो: छह जुड़वां।
खिलाड़ी तीन: छह तेरह।
खिलाड़ी एक: छह चौके।
खिलाड़ी दो: झूठ!
वे अपने पासा को प्रकट करते हैं और लोगों को गिनते हैं (क्योंकि वे जंगली हैं) और चौके हैं।
यह पता चला है कि वास्तव में, छह चौके हैं।
तो खिलाड़ी दो खिलाड़ी एक को मरवा देता है।
वे फिर से दौड़ते हैं और खिलाड़ी अगले दौर की शुरुआत करते हैं।

इस गेम को खेलने के लिए आपको एक बॉट लिखना होगा। इसे निम्नलिखित अमूर्त जावा वर्ग को लागू करना चाहिए:

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 यदि आप गोल की पहली बोली बना रहे हैं
    • आउटपुट या तो फॉर्म का एक स्ट्रिंग होना चाहिए "नंबर फेस", या स्ट्रिंग "लीयर!" पिछले बोलीदाता को झूठा कहने के लिए।
    • यदि आपका आउटपुट अवैध रूप से स्वरूपित है, तो आपको समाप्त कर दिया जाएगा।
  • आप toString पद्धति को ओवरराइड कर सकते हैं, लेकिन इसके लिए आवश्यक नहीं हैं। हालाँकि, आप इसे किसी भी तरह से संपादित नहीं कर सकते हैं जो नियंत्रक के आउटपुट की पठनीयता में हस्तक्षेप करता है।
  • आप नियंत्रक के किसी भी अन्य सार्वजनिक तरीकों कॉल करने के लिए अनुमति दी है, लेकिन कर रहे हैं नहीं इसकी मुख्य विधि।
  • आप अपने बॉट के अपने नाम के साथ पहले से चल रही निर्देशिका में केवल फाइलें पढ़ और संपादित कर सकते हैं
  • आपको किसी अन्य स्रोत से इनपुट लेने की अनुमति नहीं है
  • इंस्टेंस चर प्रत्येक नए गेम की शुरुआत में रीसेट किए जाते हैं, लेकिन स्थिर चर नहीं होते हैं।

स्कोरिंग

  • प्रत्येक में 3-5 खिलाड़ियों के साथ 1,000 खेलों का एक सेट, जब भी एक बॉट जोड़ा जाता है, हर बार सिम्युलेटेड किया जाएगा (जैसे ही तीन या अधिक बॉट प्रस्तुत किए गए हैं), जैसा कि नियंत्रक स्रोत में दिखाया गया है (किसी भी गेम में, आप अपने प्रत्येक मोड़ के प्रारंभ में 1 प्राप्त करें, 10 बार हर बार जब आप एक मृत्यु पर कब्जा करते हैं, और 1,000 बोनस यदि आप जीतते हैं); प्रत्येक खेल में 5,000 TURNS (राउंड नहीं) की सीमा लागू करना।
  • आपके बॉट को गेम के नवीनतम सेट से उसके स्कोर द्वारा प्राप्त किया जाएगा; प्लस दस बार अपने वोट स्कोर, अगर nonnegative। (उत्तरार्द्ध के स्कोर पर महत्वपूर्ण प्रभाव होने की संभावना नहीं है)

नियंत्रक स्रोत यहां पाया जा सकता है।

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
popularity-contest  king-of-the-hill  java 
— SuperJedi224
स्रोत
1
आपको यह स्पष्ट करना चाहिए कि आउटपुट "2 3" होना चाहिए न कि आपके उदाहरणों के शो की तरह "दो तिहाई" होना चाहिए। इसके अलावा, नियंत्रक में एक तरीका है कि एक मैच देख सकते हैं?
— कैन
आधिकारिक संस्करण में नहीं, लेकिन मैं एक वैकल्पिक संस्करण पोस्ट करूँगा जो आपको ऐसा करने देता है।
— सुपरजेडी २२४
@Geobits: यदि आप चाहते हैं। यह आपको किसी नुकसान में डालेगा अगर कोई आपको बुलाएगा।
— SuperJedi224
1
मुझे लगता है कि सरणियों के सूचकांक खिलाड़ियों के "आईडी" हैं, इसलिए कि diceEachPlayerHas[yourId]= आपकी पासा गिनती, और bids[yourId]आपकी पहली बोली है (या यदि यह आपकी पहली बारी है तो शून्य)। क्या वो सही है?
— नहीं कि चार्ल्स
1
मैंने ऐसे खेल देखे हैं जहाँ कुछ प्रस्तुतियाँ दूसरों की तुलना में अधिक खेल खेलती हैं (कोई नहीं: 414 खेल, स्ट्रेट शूटर: 409 गेम)। यह उचित नहीं है, क्या आप कृपया इसे ठीक कर सकते हैं?
— कॉमनग्यू

जवाबों:

6

कोई भी नहीं

अन्य खिलाड़ियों से पासा का अनुमान लगाने की कोशिश करता है। अन्य बॉट झूठे को बुलाता है अगर यह नहीं जानता कि क्या करना है।

संपादित करें: ऐसी समस्या का समाधान जहां कोई भी हमेशा के लिए बोली नहीं लगाएगा, कभी भी लियर को नहीं बुलाएगा।

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
स्रोत
अद्यतनों के आपके अंतिम सेट ने वास्तव में मदद की प्रतीत होती है।
— SuperJedi224
6

बदनाम, बॉट जो कि द्विपद वितरण के आधार पर खराब निर्णय लेता है: संपादित करें: संभाव्यता गणना में एक बेवकूफ गलती तय की, अब अगले बोलीदाता के साथ-साथ पिछले के लिए भी जिम्मेदार है।

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

}

यह यह निर्धारित करने की कोशिश करता है कि क्या यह स्वयं के लिए अनुमानित संचयी द्विपद वितरण के आधार पर ब्लर या लियर को कॉल करना चाहिए और पिछले और अगले बोलीदाताओं के पास उनके आवश्यक पासा मौजूद होने की संभावना है।

मूल रूप से, यह लियार को बुलाता है यदि पिछले बिडर को लियार होने की बहुत संभावना है या यदि यह महसूस करता है कि यह और अगला बिडर दोनों नहीं की तुलना में अधिक झूठ बोल रहे हैं।

— InactionPotential
स्रोत
इन परिवर्तनों के साथ, बदनोमियल वास्तव में अन्य बॉट्स के मुकाबले दूर से सक्षम लगता है।
— निष्क्रियता
5

सीधा निशानेबाज़

वह इसे सीधे खेलता है और झांसा नहीं देता है। वह यह सोचने के लिए भी पर्याप्त नहीं है कि अन्य लोग भी ऐसा करते हैं, इसलिए वह कभी झूठ नहीं बोलता है जब तक कि बोली में पासे की कुल संख्या से अधिक न हो जाए (अपने खुद के पासे जो बोली से मेल नहीं खाते)।

प्रत्येक मरने के लिए सटीक अपेक्षित संख्या की तुलना में थोड़ा अधिक रूढ़िवादी होने के लिए, वह अपने खुद के wilds की गिनती नहीं करता है, लेकिन यह मानता है कि दूसरों के पास एक समान वितरण है। वर्तमान चार खिलाड़ियों के साथ, या तो वह या 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;
    }
}
— Geobits
स्रोत
यह और MostlyHonestAbe दोनों झूठ बोलने या झूठ बोलने में बहुत हिचकिचाते हैं, जब मैं हाहा का परीक्षण करता हूं तो कुछ गेम 2000 मुड़ने वाले होते हैं। : पी
— कैन
उसी में मेरा। यह ठीक है, हालांकि, क्योंकि हर मोड़ अंतिम स्कोर की ओर एक अतिरिक्त बिंदु है। अगर मैं पिछले 2000 में बदल गया और जीत नहीं पाया, तो मेरी पुस्तक में 100 के बाद जीतने से बेहतर है;)
— भूत
मुझे बस फिर से स्कोरिंग नियमों को देखना पड़ा। पूरा नया गेम XD
— कैन
हाँ, इस स्कोरिंग के साथ ऐसा लगता है कि इष्टतम रणनीति के रूप में आप कर सकते हैं रूढ़िवादी हो सकता है, और बस अंक ऊपर रैक। शायद वहाँ कुछ बेहतर है, लेकिन मैं इसे नहीं देख सकता।
— जियोबिट्स
1
मुझे यकीन नहीं है कि इससे बहुत फर्क पड़ेगा। रूढ़िवादी होने के नाते अभी भी एक फायदा होगा, सिर्फ इसलिए कि आपके पास मरने की संभावना कम है। वास्तविक जीवन में अधिक लोगों के खेलने का कारण यह नहीं है क्योंकि यह सिर्फ उबाऊ है, लेकिन एक बॉट के लिए ऊब क्या है?
— भूत
4

MostlyHonestAbe

अबे बाकी विरोधियों के मरने के बारे में रूढ़िवादी अनुमान लगाता है, और फिर तब तक ईमानदार रहता है जब तक उसे नहीं लगता कि मौजूदा बोली को हरा देने के लिए पर्याप्त पासा नहीं है। इस बिंदु पर वह एक बार झांसा देता है, फिर अगली बार झूठा कहता है।

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
क्या आप मेरे साथ मजाक कर रहे हैं? मुझे HonestAbe पोस्ट करने से पांच मिनट से भी कम समय था । अब मुझे एक नया नाम सोचना है: P
— Geobits
1
कहीं इब्राहीम लिंकन संदर्भ के बिना नाम में लियार के साथ एक खेल नहीं हो सकता।
— कैन
4

डॉ घर

सब लोग झूठ बोलते हैं!

public class DrHouse extends Player
{   
  public String bid(int yourId, int[] diceEachPlayerHas, int[] yourDice, String[] bids)
  {
    return "Liar!";
  }
}
— Gus314
स्रोत
1
जब आप पहले दौर की बोली लगाते हैं तो मैं विशेष तर्क जोड़ने का सुझाव देता हूं।
— सुपरजेडी २२४
4
@ SuperJedi224 मैं कल्पना करता हूं कि बॉट तब नियंत्रक को यह बताने पर विचार करता है कि यह झूठ बोलने की उसकी बारी है
— नाथन मेरिल
मेरा दिन बना दिया
— रोहन झुनझुनवाला
2

Fidelio

यह बॉट जानता है कि केवल उसका सबसे अधिक बारंबार मूल्य उसे जीत की ओर ले जाएगा, इसलिए वह उसके साथ रहना चाहता है। वह मानते हैं कि हर किसी के पासे का एक हिस्सा उनके जैसा ही होता है, अगर कोई भी उस हिस्से से ज्यादा बोली लगाता है, तो वह मान लेता है कि वह झूठा है।

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

मुझे उम्मीद है कि वह कुछ अच्छा काम करेंगे :)।

— Katenkyo
स्रोत
मैं एक IndexOutOfBoundsException लाइन 13 पर प्राप्त कर रहा हूं। याद रखें कि एरेज़ 0-इंडेक्स जावा में हैं।
— SuperJedi224
अब मैं 1 के सूचकांक के लिए, लाइन 19 पर दूसरे छोर पर एक हो रहा हूं। ऐसा प्रतीत होता है कि यह खाली सरणी से अंतिम तत्व को पढ़ने की कोशिश कर रहा था, आपको उसके लिए एक चेक शामिल करना चाहिए।
— SuperJedi224
फिक्स्ड, अगर मैं बोलियों का उपयोग करने के बाद जाँच (बोल.लगाव = = 0) किया गया था ...
— Katenkyo
ओह, मैंने अभी एक और संभावित समाधान का प्रस्ताव दिया था, लेकिन यह संभवतः भी काम करेगा।
— SuperJedi224
आह, तो इस सुझाए गए संपादन की अब आवश्यकता नहीं है?
— mbomb007
2

सांख्यिकीविद

आपके पास इक्के के अलावा किसी भी संख्या के होने का 1/3 मौका है। एक आदमी ने एक बार मुझसे कहा था कि अपने पांसे की जाँच मत करो और बाधाओं को जानकर तुम इस खेल को जीत सकते हो। EDIT: इसकी बोली बहुत अधिक थी। लेकिन यह स्कोर में बहुत सुधार नहीं करता है।

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

बेतुका बॉट

दावा करता है कि सभी पासा 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";
    }
}
— फ्रेडरिक
स्रोत
कैसे प्रभावी के लिए: इसका मुख्य कार्य जो भी खिलाड़ी को पासा
— सौंपता प्रतीत
@Geobits मैंने कोड तय किया। ऐसा तब होता है जब आप एक प्रोग्रामिंग भाषा में कूदने की कोशिश करते हैं जिसे आपने पहले प्रोग्राम नहीं किया है ...
— frederick
@Geobits सभी मदद के लिए धन्यवाद। मुझे लगता है कि यह आखिरकार अब ठीक से काम करता है। क्या यह? (जावा भ्रामक है)
— frederick
हाँ, यह अब चलता है। रणनीति पागलपनपूर्ण आत्मघाती है, हालांकि। यह अगले-निम्नतम खिलाड़ी का केवल ~ 2% स्कोर करता है।
— जॉयबिट्स
@Geobits मैंने इसे अन्य खिलाड़ियों के खिलाफ चलाने की कभी कोशिश नहीं की। क्या आपने इसे दूसरों के खिलाफ चलाया?
— फ्रेडरिक
1

समुद्री डाकू

मैंने नियंत्रक का परीक्षण करते समय कुछ सरल बॉट बनाए, और यह एकमात्र ऐसा है जो वास्तव में अच्छा है।

संभवत: बाद में सुधार किया जाएगा।

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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.