सभी प्रविष्टियों के लिए धन्यवाद, अब समय सीमा बीत चुकी है और अंतिम स्कोर प्रश्न के अंत में हैं। एक बहुत व्यापक जीत पर PhiNotPi को
बधाई ।

यह एक राजा-की-पहाड़ी चुनौती है, जिसका उद्देश्य एक ऐसा कार्यक्रम बनाना है जो सबसे कम बोली बोली नीलामी में अपने किसी भी विरोधी की तुलना में अधिक बार जीतता है।

इनपुट

इनपुट के रूप में कार्यक्रम पिछले सभी राउंड की बोली प्राप्त करेगा, प्रति पंक्ति एक राउंड, रिक्त स्थान द्वारा अलग-अलग सभी बोलियां निम्नानुसार होंगी:

10 4 12 11 12 4 7 3 3
1 2 9 15 1 15 15 9 3
3 21 6 4 3 8 6 13 1

इनपुट का प्रत्येक कॉलम एक बॉट की बोली का प्रतिनिधित्व करता है। पहला कॉलम प्रोग्राम की बोलियां प्राप्त करना है, जबकि बाकी एक यादृच्छिक रूप से उत्पन्न क्रम में हैं। हमर और पीटर टेलर को उनके इनपुट के लिए धन्यवाद ।

इनपुट आपके प्रोग्राम के लिए केवल एक ही कमांड-लाइन (मल्टी-लाइन) तर्क के रूप में दिया गया है:

./test1 '1 2
3 4
5 6
1 2'

इसका मतलब है कि आपके प्रोग्राम को कमांड-लाइन से रन करने योग्य बनाने की आवश्यकता होगी। कृपया अपने उत्तर के हिस्से के रूप में मंगलाचरण का एक उदाहरण दें।

पहले दौर में केवल यह बताने के साधन के रूप में कि आप कितने बॉट के खिलाफ हैं, इनपुट 0प्रत्येक बॉट के लिए s - की एक पंक्ति होगी ।

उत्पादन

आपका कार्यक्रम 1 से 100 (समावेशी) सीमा में पूर्णांक के रूप में अपनी बोली का उत्पादन करना चाहिए।

स्कोरर कार्यक्रम

यह मेरा स्कोरिंग कार्यक्रम है - परिवर्धन, सुधार या बग फिक्स के किसी भी सुझाव का स्वागत किया जाएगा।

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NUMROUNDS 10
#define NUMBOTS 4
#define MAXINPUTSIZE 10000
#define MAXFILENAMESIZE 100

int main()
{
    int i,j,a,b,winner;
    FILE *fp;
    char bots[NUMBOTS][MAXFILENAMESIZE]={"onesconfident","random100","random20","random5"};
    char openstring[MAXFILENAMESIZE+MAXINPUTSIZE+3];
    char input[MAXINPUTSIZE];
    char buff[5];
    int shuffle[NUMBOTS],auction[100],lowestbid[NUMBOTS]={[0 ... NUMBOTS-1]=101};
    static int guesses[NUMBOTS][NUMROUNDS];
    static int scores[NUMBOTS],totalwinbids[NUMBOTS];

    srand(time(NULL));

    for(i=0;i<NUMROUNDS;i++)
    {
        /*blank the auction bids for the next round */
        for(a=0;a<100;a++)
        {
            auction[a]=9999;
        }

        /*loop through the bots sending the input and storing their output */
        for(j=0;j<NUMBOTS;j++)
        {
            /*Fisher-Yates shuffle */
            for(b=0;b<NUMBOTS;b++)
            {
                shuffle[b]=(b+j)%NUMBOTS;/*put current bot at index 0 */
            }
            for(b=NUMBOTS-1;b>1;b--)
            {
                int z=rand()%(b-1)+1;/*make sure shuffle leaves index 0 alone */
                int t=shuffle[b];
                shuffle[b]=shuffle[z];
                shuffle[z]=t;
            }

            /*generate the input for the bots */
            strcpy(input,"'");
            if(i==0)
            {
                for(b=0;b<NUMBOTS;b++)
                {
                    if(b!=0)
                        sprintf(input,"%s 0",input);
                    else
                        sprintf(input,"%s0",input);
                }
            }
            else
            {
                for(a=0;a<i;a++)
                {
                    for(b=0;b<NUMBOTS;b++)
                    {
                        if(b!=0)
                            sprintf(input,"%s %d",input,guesses[shuffle[b]][a]);
                        else
                            sprintf(input,"%s%d",input,guesses[shuffle[b]][a]);
                    }
                    if(a!=i-1)
                        strcat(input,"\n");
                }
            }
            strcat(input,"'");

            sprintf(openstring,"%s %s",bots[j],input);
            fp=popen(openstring,"r");

            fgets(buff,3,fp);
            fflush(NULL);
            pclose(fp);
            guesses[j][i]=atoi(buff);

            /*add the bid to the auction, eliminating any duplicates */
            if(auction[atoi(buff)-1]!=9999)
                auction[atoi(buff)-1]=9998;
            else
                auction[atoi(buff)-1]=j;
        }

        winner=9999;
        /*add one to the score of the winning bot */
        for(a=0;a<100;a++)
        {
            if(auction[a]!=9998 && auction[a]!=9999)
            {
                winner=auction[a];
                scores[winner]+=1;
                totalwinbids[winner]+=guesses[winner][i];
                if(guesses[winner][i]<lowestbid[winner])
                    lowestbid[winner]=guesses[winner][i];
                break;
            }
        }

        /*output this round's bids and the winning bot's name */
        strcpy(input,"");
        for(b=0;b<NUMBOTS;b++)
        {
            if(strcmp(input,"")!=0)
                sprintf(input,"%s %d",input,guesses[b][i]);
            else
                sprintf(input,"%d",guesses[b][i]);
        }
        if(winner!=9999)
            printf("%s %s\n",input,bots[winner]);
        else
            printf("%s No winner\n",input);
    }

    /*output final scores */
    printf("\nResults:\n");
    printf("Bot\tScore\tTotal\tLowest\n");
    for(a=0;a<NUMBOTS;a++)
    {
        printf("%s\t%d\t%d\t%d\n",bots[a],scores[a],totalwinbids[a],lowestbid[a]);
    }

    return 0;
}

खिलाड़ियों का परीक्षण करें

एक का विश्वास हमेशा बोली 1।

#include <stdio.h>

int main()
{
    printf("1");
    return 0;
}

पूरी रेंज में यादृच्छिक पर यादृच्छिक 100 बोलियाँ

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    srand(getpid());
    printf("%d",rand()%100+1);
    return 0;
}

Random20 1 और 20 के बीच यादृच्छिक पर बोलियाँ

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    srand(getpid());
    printf("%d",rand()%20+1);
    return 0;
}

1 और 5 के बीच यादृच्छिक पर random5 बोलियाँ

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    srand(getpid());
    printf("%d",rand()%5+1);
    return 0;
}

उदाहरण रन-थ्रू:

1 38 5 2 onesconfident
1 66 13 5 onesconfident
1 94 1 3 random5
1 22 9 1 random20
1 50 17 4 onesconfident
1 78 5 2 onesconfident
1 6 13 5 onesconfident
1 34 1 3 random5
1 62 9 1 random20
1 90 17 4 onesconfident

Results:
Bot Score   Total   Lowest
onesconfident   6   6   1
random100   0   0   101
random20    2   18  9
random5 2   6   3

ये खिलाड़ी केवल परीक्षण उद्देश्यों के लिए हैं। उन्हें प्रतियोगिता में शामिल नहीं किया जाएगा। आप जितने चाहें उतने बॉट्स में प्रवेश कर सकते हैं, इसलिए यदि कोई बॉट में प्रवेश करता है जो केवल अनुमान लगाता है 1, तो आप एक और दर्ज कर सकते हैं जो इसे बेकार करने के लिए करता है।

विजेता

हर दौर में जीतने बॉट एक जो सबसे कम देता है अद्वितीय बोली। इसलिए एक राउंड दिया गया जिसमें निम्नलिखित बोलियां लगाई गई हैं: 1 1 3 5 2 3 6 3 2 8 7विजेता वह बोली होगा 5क्योंकि 1s, 2s और 3s अद्वितीय नहीं हैं।

प्रतियोगिता का विजेता वह कार्यक्रम होगा जो 100 राउंड के बाद सबसे अधिक बार जीतता है। एक टाई के मामले में जीतने वाली बोलियों के कुल का उपयोग टाई-ब्रेकर के रूप में किया जाएगा, और उस टाई के होने की स्थिति में, सबसे कम जीतने वाली बोली का उपयोग आगे के टाई-ब्रेकर के रूप में भी किया जाएगा। ये स्कोरिंग कारक स्कोरिंग प्रोग्राम द्वारा सभी आउटपुट हैं।

मैं आज से 2 सप्ताह में प्रवेश करने वाले सभी कामकाजी कार्यक्रमों पर स्कोरिंग कार्यक्रम चलाऊंगा ( ~~18 फरवरी को~~ अब 20 फरवरी को 11 बजे (जीएमटी) तक बढ़ा दिया गया है )। मैं सभी कामकाजी प्रविष्टियों को बढ़ाऊंगा और अपने स्कोरिंग रन के विजेता को स्वीकार करूंगा।

अंतिम स्कोरिंग रन

1 9 3 2 1 6 4 3 6 8 7 10 26 6 10 5 26 2 5 8 8 5 7 6 42 1 ./phinotpi2
1 11 4 2 1 4 9 20 6 8 7 6 26 4 8 4 26 2 5 8 8 5 7 7 42 1 ./phinotpi2
1 7 9 2 1 4 3 20 6 8 7 6 7 4 8 9 26 2 5 8 8 5 4 9 42 3 node minitech1.js
1 13 20 2 1 3 3 20 6 8 7 7 9 6 8 20 26 2 5 8 8 5 9 9 42 3 ./dirichlet
1 12 13 2 1 1 3 20 6 8 7 7 9 6 9 13 26 2 5 8 8 5 20 9 42 3 ./dirichlet
1 2 4 2 1 1 3 20 6 8 7 7 9 6 9 12 26 2 5 8 8 5 13 9 42 3 python blazer1.py
1 11 4 2 1 4 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 12 9 42 3 ./celtschk
1 3 4 2 1 1 3 20 6 8 7 6 7 4 8 9 26 2 5 8 8 5 4 9 42 3 node minitech1.js
1 7 4 2 1 1 3 20 6 8 7 9 26 6 7 20 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 9 9 2 1 3 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 20 9 42 10 ./phinotpi2
1 13 4 2 1 3 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 12 20 2 1 1 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 10 3 2 1 2 4 20 6 8 7 6 9 3 9 3 26 2 5 8 8 5 7 9 42 10 ./phinotpi2
1 6 9 2 1 4 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 8 4 2 1 3 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./celtschk
1 2 13 2 1 3 3 20 6 8 7 9 20 6 8 9 26 2 5 8 8 5 7 9 42 10 ruby1.9 strategist.rb
1 2 4 2 1 3 3 20 6 8 7 7 10 6 9 10 26 2 5 8 8 5 9 9 42 10 python blazer1.py
1 3 13 2 1 4 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 10 9 42 10 ./celtschk
1 4 4 2 1 3 3 20 6 8 7 6 7 4 8 9 26 2 5 8 8 5 4 9 42 10 ruby1.9 strategist.rb
1 4 9 2 1 4 3 20 6 8 7 7 9 6 8 10 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 11 7 2 1 1 4 20 6 8 7 6 7 3 8 3 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 6 4 2 1 3 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 13 7 2 1 1 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 7 4 2 1 4 4 20 6 8 7 6 20 3 8 3 26 2 5 8 8 5 7 9 42 10 ./celtschk
1 13 3 2 1 1 4 20 6 8 7 6 7 3 8 9 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 3 4 2 1 3 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 9 9 42 10 ruby1.9 strategist.rb
1 5 4 2 1 2 3 20 6 8 7 6 7 4 8 10 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 6 3 2 1 3 4 20 6 8 7 6 7 3 8 3 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 10 20 2 1 1 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 10 3 2 1 4 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./celtschk
1 12 4 2 1 1 3 20 6 8 7 9 20 6 8 9 26 2 5 8 8 5 7 9 42 10 ./phinotpi2
1 5 3 2 1 1 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 13 3 2 1 4 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 6 9 2 1 4 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 5 4 2 1 2 4 20 6 8 7 6 20 3 8 3 26 2 5 8 8 5 7 9 42 10 ./celtschk
1 12 3 2 1 3 4 20 6 8 7 6 7 3 8 9 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 10 7 2 1 2 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 9 10 2 1 4 9 20 6 8 7 4 6 3 8 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 9 20 2 1 4 4 20 6 8 7 6 20 3 8 7 26 2 5 8 8 5 3 9 42 10 ruby1.9 strategist.rb
1 6 3 2 1 3 3 20 6 8 7 9 10 6 9 10 26 2 5 8 8 5 7 9 42 10 node minitech1.js
1 13 3 2 1 3 3 20 6 8 7 7 10 6 8 20 26 2 5 8 8 5 10 9 42 11 ./celtschk
1 3 3 2 1 1 3 20 6 8 7 7 26 6 9 9 26 2 5 8 8 5 20 9 42 11 ruby1.9 strategist.rb
1 5 20 2 1 2 3 20 6 8 7 7 11 6 9 11 26 2 5 8 8 5 9 9 42 11 ./phinotpi2
1 7 3 2 1 4 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 11 9 42 11 node minitech1.js
1 7 3 2 1 1 4 20 6 8 7 6 7 3 8 20 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 8 4 2 1 4 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 20 9 42 10 ./phinotpi2
1 2 3 2 1 3 9 20 6 8 7 4 6 3 8 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 4 13 2 1 3 4 20 6 8 7 6 20 3 7 7 26 2 5 8 8 5 3 9 42 10 ./celtschk
1 8 3 2 1 3 3 20 6 8 7 9 20 6 8 9 26 2 5 8 8 5 7 9 42 10 ruby1.9 strategist.rb
1 9 10 2 1 2 3 20 6 8 7 7 10 6 9 10 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 10 20 2 1 1 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 9 4 2 1 1 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 11 20 2 1 4 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 4 9 2 1 3 4 20 6 8 7 6 9 3 9 3 26 2 5 8 8 5 7 9 42 10 ruby1.9 strategist.rb
1 5 3 2 1 4 4 20 6 8 7 6 7 3 8 10 26 2 5 8 8 5 3 9 42 10 ./celtschk
1 7 4 2 1 3 3 20 6 8 7 7 9 6 8 9 26 2 5 8 8 5 10 9 42 10 python blazer1.py
1 4 9 2 1 1 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 8 4 2 1 3 9 20 6 8 7 4 6 3 8 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 10 9 2 1 3 4 20 6 8 7 6 20 3 8 7 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 4 20 2 1 1 3 20 6 8 7 6 20 4 8 4 26 2 5 8 8 5 7 9 42 10 ./phinotpi2
1 5 3 2 1 2 9 20 6 8 7 4 6 3 9 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 2 4 2 1 1 4 20 6 8 7 6 20 3 8 7 26 2 5 8 8 5 3 9 42 10 ./celtschk
1 10 12 2 1 1 3 20 6 8 7 9 20 6 8 9 26 2 5 8 8 5 7 9 42 10 ./phinotpi2
1 9 4 2 1 4 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 9 9 42 10 ruby1.9 strategist.rb
1 11 3 2 1 3 4 20 6 8 7 6 7 3 8 10 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 8 4 2 1 1 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 13 9 2 1 4 9 20 6 8 7 4 6 3 8 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 2 9 2 1 3 4 20 6 8 7 6 20 3 8 7 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 8 3 2 1 2 3 20 6 8 7 6 20 4 8 4 26 2 5 8 8 5 7 9 42 10 ./celtschk
1 3 3 2 1 4 3 20 6 8 7 6 7 4 8 9 26 2 5 8 8 5 4 9 42 10 ruby1.9 strategist.rb
1 10 4 2 1 1 3 20 6 8 7 7 9 6 8 10 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 3 9 2 1 4 4 20 6 8 7 6 7 3 8 3 26 2 5 8 8 5 10 9 42 10 node minitech1.js
1 7 11 2 1 4 4 20 6 8 7 6 7 3 8 20 26 2 5 8 8 5 3 9 42 10 ./celtschk
1 8 3 2 1 2 3 20 6 8 7 7 9 6 8 9 26 2 5 8 8 5 20 9 42 10 ruby1.9 strategist.rb
1 3 10 2 1 3 3 20 6 8 7 7 10 6 9 10 26 2 5 8 8 5 9 9 42 10 node minitech1.js
1 8 4 2 1 1 3 20 6 8 7 7 10 6 8 20 26 2 5 8 8 5 10 9 42 11 ./phinotpi2
1 2 4 2 1 2 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 20 9 42 11 ruby1.9 strategist.rb
1 4 9 2 1 4 4 20 6 8 7 6 7 3 8 11 26 2 5 8 8 5 3 9 42 11 node minitech1.js
1 4 9 2 1 1 3 20 6 8 7 7 11 6 8 20 26 2 5 8 8 5 11 9 42 10 ./phinotpi2
1 2 7 2 1 1 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 20 9 42 10 ./phinotpi2
1 9 3 2 1 1 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 3 9 2 1 2 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ruby1.9 strategist.rb
1 5 7 2 1 3 3 20 6 8 7 10 20 6 8 10 26 2 5 8 8 5 7 9 42 10 ./celtschk
1 8 10 2 1 4 3 20 6 8 7 7 10 6 9 9 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 5 4 2 1 4 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 9 9 42 10 ruby1.9 strategist.rb
1 5 20 2 1 3 4 20 6 8 7 6 7 3 8 10 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 11 20 2 1 2 3 20 6 8 7 6 7 4 8 4 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 12 10 2 1 1 9 20 6 8 7 4 6 3 9 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 10 3 2 1 1 4 20 6 8 7 6 20 3 8 7 26 2 5 8 8 5 3 9 42 10 ./phinotpi2
1 9 4 2 1 4 3 20 6 8 7 6 20 4 8 4 26 2 5 8 8 5 7 9 42 10 ./phinotpi2
1 5 3 2 1 1 9 20 6 8 7 4 6 3 8 3 26 2 5 8 8 5 4 9 42 10 scala Schwarzenbeck
1 7 4 2 1 1 4 20 6 8 7 6 20 3 7 7 26 2 5 8 8 5 3 9 42 10 ./celtschk
1 11 7 2 1 3 3 20 6 8 7 9 20 6 8 9 26 2 5 8 8 5 7 9 42 10 ruby1.9 strategist.rb
1 13 10 2 1 1 3 20 6 8 7 7 10 6 9 10 26 2 5 8 8 5 9 9 42 10 ./phinotpi2
1 9 9 2 1 1 4 20 6 8 7 6 7 3 9 3 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 7 9 2 1 3 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 ruby1.9 strategist.rb
1 13 7 2 1 4 3 20 6 8 7 6 7 4 8 10 26 2 5 8 8 5 4 9 42 10 ./phinotpi2
1 8 7 2 1 1 4 20 6 8 7 6 7 3 8 3 26 2 5 8 8 5 10 9 42 10 ./phinotpi2
1 12 3 2 1 1 9 20 6 8 7 4 6 3 8 4 26 2 5 8 8 5 3 9 42 10 scala Schwarzenbeck
1 13 7 2 1 2 3 20 6 8 7 6 20 4 8 7 26 2 5 8 8 5 4 9 42 10 ./phinotpi2

Results:
Bot                 Score   Total   Lowest
perl phinotpi1.pl           0   0   101
./dirichlet                 2   25  12
python blazer1.py           3   12  4
perl chef.pl ilmari2.chef   0   0   101
./brainfuck ilmari1.bf      0   0   101
./christophe1               0   0   101
./phinotpi2                 44  156 3
node minitech1.js           7   140 20
scala Mueller               0   0   101
scala Beckenbauer           0   0   101
scala Schwarzenbeck         15  105 7
./alice                     0   0   101
./bob                       0   0   101
./eve                       0   0   101
python joe.py               0   0   101
python copycat.py           0   0   101
python totalbots.py         0   0   101
perl healthinspector.pl     0   0   101
./mellamokb1                0   0   101
./mellamokb2                0   0   101
php eightscancel.php        0   0   101
php fivescancel.php         0   0   101
python copycat2.py          0   0   101
./celtschk                  14  126 9
./deepthought               0   0   101
ruby1.9 strategist.rb       15  152 10

king-of-the-hill

— गैरेथ
स्रोत

1

हम्म ... नियम के रूप में वे हैं, मैं वास्तव में 100 कार्यक्रमों में प्रवेश करके खेल को खराब कर सकता हूं कि प्रत्येक हमेशा किसी दिए गए नंबर पर बोली लगाता है।

— इल्मरी करोनें

1

क्या आप दो वाक्य कह सकते हैं कि जीतने वाला बॉट कैसे चुना जाता है? मुझे नहीं मिला।

— उपयोगकर्ता अज्ञात

@ इल्मारिकारोन यह सच है, आप कर सकते हैं। लेकिन मुझे भरोसा है कि लोग ऐसा नहीं करेंगे। मैं मान सकता हूं कि मैं प्रति व्यक्ति प्रविष्टियों की संख्या को सीमित कर सकता हूं, लेकिन मुझे लगता है कि मैं केवल उसी का सहारा लूंगा, यदि कोई स्पॉइलर साथ आए।

— गारेथ

@userunknown मैंने स्पष्ट करने की कोशिश की है कि नीलामी के दौर कैसे काम करते हैं।

— गारेथ

1

@PhiNotPi: दोषी महसूस मत करो। आपने नियमों के भीतर जीत हासिल की।

— स्टीवन रूंबल्स्की

9

पर्ल

मैंने इस बार थोड़ी कोशिश की। यह वास्तव में ~~सरल~~ जटिल रणनीति है, लेकिन मैंने विस्तार के लिए रूपरेखा तैयार की है।

संपादित करें: पूर्ण फिर से करें। जीत के लिए यह चीज उसमें है।

    sub prob{
$_[0]+$_[1]-$_[0]*$_[1]
}

$_=<>;
INPUT:{

tr/ /,/;
@in = eval;
for(1..$#in){
 $bids[$rnum][$in[$_]]++
}
for(0..$#in){
 $tbids[$rnum][$in[$_]]++
}
$rnum++;
$_=<>;
if($_ ne"\n"){redo INPUT}
}

for(0..100){$pre[$_]=0}

dirichlet: for(2..$#in/2+2){    #rough approximation, 
$pre[$_]=prob($pre[$_], 1/int($#in/2+1))
}

CDP:{
    @cdps1=(1,1,1,2,2,3,3,4);
    @cdps2=(-2,-1,0,1,1,2,2,3,3);
    for($a=0;$a<8;$a++){
    for($b=0;$b<9;$b++){
     $sum=$cdps1[$a]+$cdps2[$b];
     if($sum<1){$sum=1};
     $pre[$sum] = prob($pre[$sum], 1/72);
    }
    }
}

blazer: {
for($r=1;$r<$rnum;$r++){
winner: for($pnt=1;$pnt<101;$pnt++){
        if($tbids[$r][$pnt] == 1){
            if($pnt > 2){
                $winnum[$pnt]++;
            $wins++;
            }
        last winner
        }
}
    }
    if($wins==0){
    $pre[3]=prob($pre[3], 1);last blazer
    }
    for(1..100){
    $pre[$_]=prob($pre[$_], $winnum[$_]/$wins);
    }
}

CC1: for($pnt=1;$pnt<101;$pnt++){
    if($tbids[$rnum-1][$pnt] == 1){
        $pre[$pnt] = prob($pre[$pnt], 1);last CC1
    }
    if($pnt==100){
        for($pnt2=1;$pnt2<100;$pnt2++){
        $pre[$pnt2] = prob($pre[$pnt2], $tbids[$rnum-1][$pnt2]/($#in+1));
    }
    }
}

CC2: for($pnt=1;$pnt<101;$pnt++){
    if($rnum-2<0){$pre[7] = prob($pre[7], 1);last CC2}
    if($tbids[$rnum-2][$pnt] == 1){
        $pre[$pnt] = prob($pre[$pnt], 1);last CC2
    }
    if($pnt==100){
        $pre[7] = prob($pre[7], 1);last CC2
    }
}

one: {
$pre[1] = prob($pre[1], 1);
}

two: {
$pre[2] = prob($pre[2], 1);
}

five: {
$pre[5] = prob($pre[5], 1);
}

eight: {
$pre[8] = prob($pre[8], 1);
}

fortytwo: {
$pre[42] = prob($pre[42], 1);
}

mueller: {
    $a=($#in+2)/4;
    $pre[int$a]=prob($pre[int$a], 1)
}

schwarzenbeck: {
    $a=($#in+2)/4+1;
    $pre[int$a]=prob($pre[int$a], 1)
}

beckenbauer: {
    $a=($#in+2)/4+2;
    $pre[int$a]=prob($pre[int$a], 1)
}

totalbots: {
    $pre[$#in+1]=prob($pre[$#in+1], 1)
}

joe: {
$sum=0;
    for(1..100){
    $sum+=$tbids[$rnum-1][$_];
}
    $average=$sum/($#in+1);
    if($average==0){$average=10};
    $pre[$average]=prob($pre[$average], 1);
}

node: {
$max=0;$maxloc=0;
for(1..100){
    if($tbids[$rnum-1][$_]>$max){$max=$tbids[$rnum-1][$_];$maxloc=$_}
}
$maxloc--;
#if($maxloc==0){
$maxloc=20;
#}
if($rnum==1){$maxloc=3}
    $pre[$maxloc]=prob($pre[$maxloc], 1);
}
#print"\n@pre\n\n";

decide: for(1..100){if($pre[$_]<0.5){print; last decide}}

यह कार्यक्रम एक समय में एक लाइन लेता है, उसके बाद दो नए समाचार आते हैं:

perl PhiNotPi2.plx
1 2 3 3 2
2 1 3 1 3
2 1 1 1 3
[empty line]

— PhiNotPi
स्रोत

ठीक है, यह मेटागैमिंग को चरम सीमा तक ले जाता है।

— पीटर टेलर

@petertaylor क्या मैं लाइन से बहुत दूर जा रहा हूं? क्या मुझे अपने मूल में वापस आना चाहिए?

— PhiNotPi

2

यह नियमों के वकीलों के लिए कुख्यात एक साइट है - यह पूरी तरह से उचित है। लेकिन मैं इस नतीजे पर पहुंच रहा हूं कि हो सकता है कि स्टैक एक्सचेंज मैकेनिज्म किंग-ऑफ-द-हिल प्रतियोगिताओं के लिए सबसे अच्छा न हो।

— पीटर टेलर

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

— PhiNotPi

लोल, यह मेरा विचार था: पी। जब से आप पहले से ही लागू कर चुके हैं, और मैं आलसी महसूस कर रहा हूं, तो मैं आपको यह

— बता दूंगा

8

महाराज

चूँकि हमेशा 1 सट्टेबाजी अब एक हारी हुई रणनीति है , इसके लिए स्पष्ट बात यह है कि इसके बजाय हमेशा 2 दांव लगाएं । तो मुझे ऐसा करने दो। यह अन्यथा उबाऊ प्रविष्टि को थोड़ा और दिलचस्प बनाने के लिए, मैंने इसे शेफ में लिखने का फैसला किया :

Shirred Eggs.

This recipe prints the number 2 and, in doing so, yields two delicious
shirred eggs.

Ingredients.
2 eggs

Cooking time: 12 minutes.

Pre-heat oven to 175 degrees Celsius.

Method.
Put eggs into mixing bowl. Pour contents of the mixing bowl into the
baking dish. Shirr the eggs. Bake the eggs until shirred.

Serves 1.

एक बोनस के रूप में, कार्यक्रम वास्तव में कम या ज्यादा वास्तविक - अगर तुच्छ - नुस्खा के रूप में काम करता है, भले ही वह इस तरह से पढ़ा हो जैसे कि लेखक थोड़ा, उम्म, बेक्ड था। शेफ व्याकरण में कुछ भी लिखना बहुत कठिन लगता है, जिसमें एक कटोरे में सामान मिलाने और उसे पकाने से कुछ अधिक जटिल होता है और फिर भी यह एक कार्यक्रम के रूप में और नुस्खा के रूप में दोनों काम करता है, खासकर यदि कोई क्रिया का उपयोग करना चाहता है। थोड़ा अनियमित भी हैं (जैसे "फ्राई" → "फ्राइड")।

संपादित करें: तली हुई से जर्जर अंडे तक नुस्खा बदल दिया - सुझाव के लिए ब्लेज़र को धन्यवाद! खाना पकाने के समय और तापमान को केवल सलाहकार माना जाना चाहिए; मैंने वास्तव में स्वयं अभी तक नुस्खा की कोशिश नहीं की है, इसलिए मैं उनकी सटीकता के लिए वाउच नहीं कर सकता।

— इल्मरी करोनें
स्रोत

मुझे लगता है कि यह आउटपुट 1: मेरी टिप्पणी को codegolf.stackexchange.com/a/4851 पर देखें ।

— msh210 19

यह 2 आउटपुट करता है, कम से कम Acme :: Chef दुभाषिया का उपयोग करके । अंतिम लूप वहां सिर्फ मोटापे के लिए होता है, और इसलिए कि खाने वालों को अंडे को कच्चा नहीं खाना पड़ेगा।

— इल्मरी करोनें

आह, ठीक है, मैंने इस तथ्य को याद किया कि अंडे पहले से ही बेकिंग डिश में थे और यह कि क्या कमी नहीं है।

— msh210

2

आप इसे कहते हैं shirred eggs, जो वास्तव में एक बेकिंग डिश में किया जाता है और यह नुस्खा को एक वास्तविक वैध खाना पकाने की विधि और व्याकरणिक रूप से सही बना देगा। shirr the eggs. shirr the eggs until shirred.मेरी बेल्ट के नीचे पाक शिक्षा होने के लिए भय! :)

— ब्लेज़र

1

खाना पकाने का समय / तापमान सही लगता है :)। बेशक, हमेशा उन दिशा निर्देशों के रूप में ही उपयोग करें, क्योंकि यह वह शेफ है जो निर्धारित करता है कि कुछ किया गया है या नहीं, समय / तापमान ही नहीं!

— ब्लेज़र

4

पायथन (2.6)

बेहद सरल, लेकिन फिर भी मैं उत्सुक हूं कि यह अन्य तरीकों की तुलना में कैसा प्रदर्शन करेगा।

import sys, random
try:
    s = sys.stdin.readlines()[-2]
    m = min(int(x) for x in s.split())
except IndexError:
    m = random.choice([1,1,1,2,2,3,3,4])
a = random.choice([-2,-1,0,1,1,2,2,3,3])
print max(m + a, 1)

बस स्टड के माध्यम से बोलियों में पाइप, जैसे python testbid.py < bids.txt।

संपादित करें : 'पहले दौर के सभी शून्य' के लिए परिवर्तित

संपादित करें : 'मैजिक नंबर' को थोड़ा बदला (दूसरी बार)

— ChristopheD
स्रोत

1

नहीं m = random.choice(1,2,2,3,3,3)होना चाहिए m = random.choice([1,2,2,3,3,3])?

— ब्लेज़र

यह एक त्रुटि फेंक दिया जहां ब्लेज़र ने कहा कि यह हो सकता है। मैंने टेस्ट रन के लिए स्क्वायर कोष्ठक में रखा है और यह काम करने के लिए प्रतीत होता है।

— गारेथ

@ ब्लेज़र: हाँ, बिल्कुल (मेरी ओर से छोटा टाइपो)। अधिसूचित करने के लिए धन्यवाद।

— क्रिस्टोफ़ेद

4

अजगर (ब्लेज़र)

यह बॉट पिछले राउंड का विश्लेषण करता है और जीतने वाले नंबरों को रिकॉर्ड करता है। जीतने वाली संख्याएं जो अधिक बार दिखाई देती हैं, इसलिए उन्हें उठाया जाने की बेहतर संभावना होगी। यह तब बेतरतीब ढंग से जीतने वाली संख्याओं (1 या 2 के अलावा) से संख्याओं का चयन करेगा। यह 2 3 का चयन करेगा बजाय अगर यह पहला दौर है।

इनपुट को एक बार में एक लाइन पढ़ा जाता है। इनपुट स्वीकार करने से रोकने के लिए बस एक खाली लाइन दर्ज करें

एक चाल सिर्फ चिपकाने की है (यह पेस्ट के भीतर प्रत्येक पंक्ति को \ n के साथ स्वीकार करता है) और दो बार दर्ज करें

अब आप स्क्रिप्ट को कमांड लाइन में फ़ाइल नाम के साथ चला सकते हैं:

python bidding.py bidding.txt

फ़ाइल इस तरह दिखनी चाहिए:

10 4 12 11 12 4 7 3 3
1 2 9 15 1 15 15 9 3
3 21 6 4 3 8 6 13 1

-

import random
import sys

winning = [] # record the winning numbers

content = sys.argv[1].split('\n')  
for each in content:
    x = map(int, each.split())
    if len(x)+sum(x) == 0: 
        continue 

    y = []
    for each in x:
        if x.count(each) == 1:
            y.append(each)
    if len(y) > 0: 
        if min(y) not in [1,2]:  #never choose 1 or 2
            winning.append(min(y))

# choose an output
if len(winning) == 0:
    print 3
else:
    print random.choice(winning)

संपादित करें: or sum(rounds) == 0हाल ही के पहले-दौर-शून्य परिवर्तन की भरपाई करने के लिए जोड़ा गया

संपादित करें: निर्धारित टिप्पणियों में समस्याओं, यह भी एक फ़ाइल नाम से इनपुट प्राप्त करने में सक्षम बनाता है, और कभी भी '2' का चयन नहीं करता है क्योंकि प्रतिस्पर्धा ने बाहर भी मातम किया है। प्रारंभिक इनपुट के रूप में या तो सभी के साथ काम करता है या फ़ाइल में कोई डेटा बिल्कुल नहीं है

edit2: एक मिनट भूल गए ()

edit3: प्रश्न की इनपुट आवश्यकताओं के अनुरूप इनपुट बदला

— रंगीन जाकेट
स्रोत

स्कोरर के साथ एक छोटी सी समस्या - मुझे प्रत्येक राउंड के लिए स्कोर प्राप्त करने के लिए एंटर दबाना होगा। मेरे 10 राउंड टेस्ट रन के लिए ज्यादा समस्या नहीं है, लेकिन 100 राउंड रन के लिए दर्द हो सकता है।

— गारेथ

@ गैरेथ, इसे बैश स्क्रिप्ट में लपेटो। echo "$@" | python bidding.pyकाम करना चाहिए।

— पीटर टेलर

मैंने पीटर के सुझाव के अनुसार यह कोशिश की है, लेकिन मुझे TypeError: unsupported operand type(s) for +: 'int' and 'list'23 लाइन के लिए एक त्रुटि मिल रही है । मैं पायथन 2.6.1 का उपयोग कर रहा हूं, क्या यह समस्या है? क्या मुझे एक नए संस्करण की आवश्यकता है? मुझे बैश स्क्रिप्ट का उपयोग किए बिना एक ही समस्या मिलती है।

— गारेथ

@ गैरेथ यह मदद करेगा अगर मैंने इसे बनाया है तो इनपुट को sys.argv [1] से फ़ाइल नाम के साथ पाइप किया जाता है?

— ब्लेज़र

@ ब्लेज़र मुझे यकीन नहीं है कि यह समस्या है। मैं कमांड लाइन से अपने उदाहरण के आह्वान का उपयोग करके कार्यक्रम को बुला रहा हूं और मुझे ऊपर दी गई त्रुटि मिल रही है। वहाँ कुछ है कि वहाँ अजगर 2.6.1 के साथ असंगत है?

— गारेथ

3

श्वार्जनेबेक (स्काला)

object Schwarzenbeck extends App {
  println ((args(0).split('\n')(0).split(' ').length+1)/4+1)
}

श्वार्जनबेक को गोल नहीं करना चाहिए। वह बेकेनबॉयर के लिए सफाई है, जो जल्द ही अनुसरण करता है। :)

इसका उपयोग करने के लिए, आपको एक संकलक की आवश्यकता है और इसे संकलित करें

scalac Schwarzenbeck.scala

तब आप इसे चला सकते हैं:

scala Schwarzenbeck 'your ar-
gu-
ment'

संपादित करें: आगे का समायोजन।

— अज्ञात उपयोगकर्ता
स्रोत

1

यह देखते हुए कि श्वार्ज़ेनबेक को गोल नहीं करना चाहिए था, मैं कहूंगा कि यह पूरी तरह से विफल रहा है :-)

— celtschk

हां, मुझे एक दुविधा थी: मैंने 3 खिलाड़ियों की एक पंक्ति बनाई, और मुलर से सबसे अधिक अंक हासिल करने की उम्मीद की, लेकिन एक रणनीतिक स्थिति से, श्वार्ज़ेनबेक ने अंतिम रक्षा पंक्ति को चिह्नित किया। फुटबॉल रूपक विफल हो गया, क्योंकि मेरी रक्षा पंक्ति ने गोल किए। :)

— उपयोगकर्ता अज्ञात

3

रणनीतिकार (रूबी)

सैकड़ों सरल रणनीतियों को लागू करता है: प्रत्येक दौर के लिए, वह उठाता है जिसने सबसे पिछले दौर जीते होंगे:

require 'Matrix'
def winner guesses
  g=guesses.sort
  while g[0]&&g[0]==g[1]
    g.shift while g[0]==g[1]
    g.shift
  end
  g[0]
end

def prob g
  prob=[0]*100;best=0;n=g.size*(g[0].size-1)
  g.each{|r|r[1..-1].each{|v|prob[v-1]+=1.0/n}};
  prob.map!{|v|v/n}
end    

def regression x, y, degree
  return y if x.size==1 
  x_data = x.map {|xi| (0..degree).map{|pow| (xi**pow.to_f) }}
  mx = Matrix[*x_data]
  my = Matrix.column_vector y
  begin
    r = ((mx.t * mx).inv * mx.t * my).transpose.to_a[0]
  rescue Exception => e
    r=[0]*degree;r[-1]=y[-1].to_f/(x[-1]**degree)
  end
  r
end

brains=((1..50).map{|w|[proc{|g|w},
    proc{|g|best=0;(p=prob g).each_with_index{|v,i|
      best=i if(v+i/100.0/w)<p[best]};best+1}]}+
  (1..7).map{|w|[proc{|g|p=1; if (g[1]) then h=g[1..-1];x=(1..h.size).to_a
      p=0;regression(x,h.map{|r|winner r},w).each_with_index{|v,i|
      p+=v*(g.size**i)};end;p.to_i},
    proc{|g|b=g[0].size/4;if g[1] then pred=[];h=g[1..-1]
      x=(1..h.size).to_a;h[0].size.times{|i|p=0
      regression(x,h.map{|r|r[i]},w).each_with_index{|v,i|p+=v*((x[-1]+1)**i)}
      pred<<[[p.to_i,1].max,100].min}
      (1..100).each{|i|if !pred.include?(i) then b=i;break;end};end;b}]}+
  (-1..1).map{|w|[proc{|g|r=g[0].size; if g.size>1 then
      f=g[1..-1].flatten;r=(f.inject{|s,v|s+v}/f.size.to_f+w).to_i;end;r},
    proc{|g|r=g[0].size/2; if g.size>1 then
      r=(g[1..-1].inject(0){|s,v|s+winner(v)}/(g.size.to_f-1)+w).to_i;end;r},
    proc{|g|(winner(g[-1])||9)+w}  ]}+
  [proc{|g|b=0;(p=prob g).each_with_index{|v,i|b=i if v<p[b]};b+1}]).flatten

games = ARGV[0].split("\n").map{|l|l.split.map{|v|v.to_i}}
winpct=[0]*brains.size
(games.size-1).times{|round|
  entries=games[round+1].dup
  brains.each_with_index{|b,i|
    entries[0]=pick=[b[games[0..round]],1].max
    winpct[i]+= 1.0/games.size if winner(entries)==pick 
  }
}
best=0;
winpct.each_index{|i|best = i if (winpct[i]>winpct[best])}
puts brains[best][games]

मुझे यकीन नहीं है कि मुझे इनपुट प्रारूप सही मिल गया है - मुझे यकीन नहीं है कि यह विंडोज़ पर परीक्षण के लिए मल्टी-लाइन कमांड लाइन तर्क कैसे उत्पन्न करता है। (यह तरीका IDEone पर काम करता है।)

— AShelly
स्रोत

मैं अभी इसका परीक्षण नहीं कर सकता, मैं काम पर हूँ और 9.30 (GMT) के बाद तक घर नहीं जाऊँगा। क्या यह SO प्रश्न बहु-लाइन तर्कों के साथ मदद करता है?

— गारेथ

बस यह परीक्षण किया है और यह मुझे एक त्रुटि दे रहा है -

strategist.rb:48:in 'each': No such file or directory - 42 2 6 10 8 6 5 7 6 1 5 8 3 6 3 4 26 2 10 1 26 8 42 5 3 7 (Errno::ENOENT)

। मैं 11PM के बाद नई प्रविष्टियों पर विचार करना बंद कर दूंगा, लेकिन अगर आप चाहें तो बग को देखने का समय देने के लिए मैं स्कोरिंग रन में थोड़ा विलंब करूंगा।

— गारेथ

ठीक है, मुझे लगता है कि समस्या यह थी कि आपके पास ARGFएआरजीवी के बजाय था । उस परिवर्तन को करने के बाद 1हर बार कार्यक्रम का अनुमान लगाया जाता है। किसी भी विचार मैं इसे ठीक करने के लिए क्या कर सकता हूं?

— गारेथ

क्या आप इस पंक्ति को शीर्ष पर जोड़ सकते हैं और मुझे बता सकते हैं कि यह 2 राउंड इनपुट देते समय क्या प्रिंट करता है (डेटा की 2 पंक्तियाँ): p ARGV.map{|l|l};exit (एसओ में से कोई भी आपके द्वारा संदर्भित प्रश्न या इससे मिलते-जुलते उत्तर नहीं देता)

— एएसएचली

यह ["1 2\n3 4\n5 6\n1 2"]प्रश्न में परीक्षण इनपुट के लिए प्रिंट करता है ।

— गारेथ

2

पर्ल

मुझे लगा कि मैं अपरिहार्य रूप से प्रवेश कर सकता हूं। अधिक गंभीर प्रविष्टियाँ जल्द ही आ रही हैं। एक बोनस के रूप में, यह प्रविष्टि एक-पर-एक प्रतियोगिता में कभी नहीं खोएगी।

print 1

— PhiNotPi
स्रोत

हर प्रतियोगिता नहीं जीती। एक दूसरे के साथ एक दूसरे के संबंध में, यह टाई करेगा

— ब्लेज़र

नहीं! मैं विश्वास नहीं कर सकता कि मैं उस मामले के बारे में भूल गया! मैं ठीक कर दूँगा।

— PhiNotPi

मेरे निष्कर्ष में से एक जब मैंने अपनी प्रविष्टि को डिजाइन करना शुरू किया, तो यह है कि प्रत्येक बॉट को कम से कम 1 / n समय जमा करना चाहिए, ताकि अपने आप को उसके साथ चलने से रोकने में अपना उचित हिस्सा कर सकें।

— पीटर टेलर

@Peter: चिंता न करें, मैंने इसका ध्यान रखा । :)

— इल्मरी करोनें

2

जावास्क्रिप्ट (नोड.जेएस)

गिना जाता है कि अंतिम दौर में कौन सी सबसे लोकप्रिय थी और पहले दौर की तुलना में 20 और बोली 3 से कम थी।

var lastRound = /[^\n]+$/.exec(process.argv[2]);
var numbers = {};
var re = /\d+/g;
var match;

while(match = re.exec(lastRound)) {
    numbers[match] = numbers[match] >>> 0 + 1;
}

var maxKey = -1;

for(var i in numbers) {
    if(maxKey === -1 || numbers[i] > numbers[maxKey]) {
        maxKey = i;
    }
}

if(maxKey == 0) {
    // First round. Bid 3.
    console.log(3);
} else if(maxKey == 1) {
    // Bid 20.
    console.log(20);
} else {
    // Bid one less.
    console.log(maxKey - 1);
}

कैसे आह्वान करें:

node script.js 'the argument'

— Ry-
स्रोत

सबसे हालिया टेस्ट रन के परिणामों को देखते हुए, यह दस्तावेज के रूप में व्यवहार नहीं करता है। कोई विचार क्यों नहीं?

— पीटर टेलर

1

@PeterTaylor मुझे आश्चर्य है कि क्या यह पहला forलूप है? चाहिए if(i in numbers)होना if(matches[i] in numbers)आपको लगता है?

— गैरेथ

@minitech इसके चारों ओर थोड़े थूकने के बाद, ऐसा लग रहा है कि रेगेक्स केवल इनपुट के एक नंबर से मेल खा रहा है - जावास्क्रिप्ट या नोडज के बारे में पर्याप्त नहीं जानता कि यह कहने में सक्षम होने के लिए कि क्यों। इसके अलावा, क्या आपको अंतिम दौर पाने के लिए इनपुट को नए सिरे से विभाजित करने की आवश्यकता है?

— गैरेथ

@ गैरेथ: वास्तव में यह है। अद्यतन, हालांकि अगर यह मूल रूप से बेहतर प्रदर्शन करता है तो मुझे कोई आपत्ति नहीं है :)

— Ry-

दुर्भाग्य से यह अब पहले को छोड़कर हर दौर के लिए एक त्रुटि है:

node.js:201         throw e; // process.nextTick error, or 'error' event on first tick  TypeError: Cannot read property 'length' of null     at Object.<anonymous> (minitech1.js:6:23)

— गैरेथ

2

अजगर (CopyCat)

फिर भी एक और, इस बार यह उस सटीक उत्तर की नकल करता है जो अंतिम विजेता के पास था, अगर एक था। यह जीतने के लिए और अन्य बोलीदाताओं को ब्लॉक करने के लिए दोनों के लिए dsign है। बोलियों को 5पहले दौर है, पिछले दौर से एक यादृच्छिक संख्या की बोली लगाता है अगर वहाँ किसी भी तरह कोई विजेता था

content = sys.argv[1].split('\n')
x = map(int, content[-1].split())
y = []
for each in x:
    if x.count(each) == 1:
        y.append(each)
print min(y) if sum(y) > 0 else random.choice(x) if sum(x) > 0 else 5

— रंगीन जाकेट
स्रोत

2

अजगर (जो)

यह जीतने के लिए डिज़ाइन किए गए किसी भी तरह से नहीं है, लेकिन मैं इसे किसी भी तरह से भीड़ में कुछ रंग जोड़ने के लिए बाहर फेंक रहा हूं :) यह अंतिम दौर के औसत (औसत जो) की बोली लगाता है। मेरे जैसा ही है मूल उत्तर (जिसे मैं अब नाम दूंगा, क्योंकि यह ऐसा लगता है कि सभी शांत बच्चे क्या कर रहे हैं, और यह दोनों को अलग करने में मदद करता है) के समान है। यदि दौर शुरू होता है, तो वह बोली लगाता है 10।

content = sys.argv[1].split('\n')  
x = map(int, content[-1].split())
print sum(x)/len(x) if sum(x) != 0 else 10

संपादित करें: प्रश्न की इनपुट विधि के अनुरूप इनपुट की परिवर्तित विधि

— रंगीन जाकेट
स्रोत

2

अजगर (TotalBots)

मुझे लगता है कि यह मेरा आखिरी होगा, लेकिन हम देखेंगे। यह यह जानने के लिए कि कितने बॉट हैं, केवल प्रतिस्पर्धा वाले बॉट्स की संख्या को आउटपुट करने के लिए आउटरेंज लेता है, इसलिए यदि 17 बॉट्स (बॉट्स की वर्तमान संख्या, प्लस यह एक) है, तो यह आउटपुट करेगा17

content = sys.argv[1].split('\n')
print len(content[-1].split())

— रंगीन जाकेट
स्रोत

2

पर्ल (स्वास्थ्य निरीक्षक)

print ((((((2)**(2))*((2)**(2)))/((((2)**(2))*(2))*(2)))+((((2)**(2))*(2))/((2)+((2)*(((((2)**(2))+((2)*(2)))+(((2)*(2))/((2)**(2))))**(((2)/(2))/(2)))))))+((((2)-(2))/((((2)**(2))+(2))*((2)+(2))))*(rand(2))))

मुझे यकीन है कि आप अनुमान लगा सकते हैं कि यह क्या करता है।

— PhiNotPi
स्रोत

2

सी ++ (शिक्षित अनुमान)

मैंने पहले ही सोचा था कि मैं समय सीमा से चूक जाएगा, लेकिन विस्तार के लिए धन्यवाद मैं अभी भी अपनी प्रविष्टि जोड़ सकता हूं। यह कार्यक्रम जी ++ के साथ संकलित करता है। कार्यक्रम अन्य प्रविष्टियों के आंकड़ों का अनुमान लगाने की कोशिश करता है, और सबसे छोटा चुनने के लिए किसी अन्य द्वारा चुने जाने की संभावना नहीं है।

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <deque>
#include <cstdlib>
#include <ctime>
#include <exception>
#include <stdexcept>

typedef std::vector<int> botvec;
typedef std::vector<botvec> scorevec;

// read all the scores from the given string
// note that this only does minimal error checking
// the result is a vector of vector, each entry of which
// represents one round. That is, the vectors in the vector
// correspond to the lines of the command line argument.
scorevec read_past_scores(char const* scoretext)
{
  scorevec past_scores;

  std::istringstream is(scoretext);
  std::string line;

  scorevec::size_type size = 0;

  while (std::getline(is, line))
  {
    past_scores.push_back(botvec());

    std::istringstream ils(line);
    int i;
    while (ils >> i)
      past_scores.back().push_back(i);
    if (size == 0)
      size = past_scores.back().size();
    else if (past_scores.back().size() != size)
      throw std::runtime_error("invalid score format");
  }
  return past_scores;
}

struct counts { int count[100]; };
struct prob { double p[100]; };

int generate_answer(scorevec& past_scores)
{
  int const number_of_players = past_scores.front().size();
  if (past_scores.front().front() == 0) // initial round
    past_scores.pop_back();

  // Pre-fill the counts to get reasonable probabilities also for
  // insufficient statistics (and the statistics *will* be
  // insufficient!). Bias in favour of small numbers.
  counts initial;
  for (int i = 0; i < 100; ++i)
    initial.count[i] =
      i < number_of_players? 100*(number_of_players-i) : 1;

  std::deque<counts> playercounts(number_of_players, initial);

  // add the actual guesses (with a high factor, to give them high
  // weight against the initial counts)
  for (int i = 0; i < past_scores.size(); ++i)
    for (int j = 0; j < number_of_players; ++j)
      playercounts[j].count[past_scores[i][j]-1]+=5000;

  // drop the own guesses
  playercounts.pop_front();

  // calculate the probabilities corresponding to the counts
  std::vector<prob> playerprobabilities(playercounts.size());
  for (int i = 0; i < playercounts.size(); ++i)
  {
    double sum = 0;
    for (int k = 0; k < 100; ++k)
      sum += playercounts[i].count[k];
    for (int k = 0; k < 100; ++k)
      playerprobabilities[i].p[k] = playercounts[i].count[k]/sum;
  }

  // for each selection, estimate the expected number of other players
  // who will bet on it. Return the first one with an expectation
  // below 1.5.
  for (int i = 0; i < 100; ++i)
  {
    double estimate = 0;
    for (int j = 0; j < number_of_players; ++j)
      estimate += playerprobabilities[j].p[i];
    if (estimate < 1.5)
      return i+1;
  }

  // in the unlikely case that such a choice doesn't exist (meaning
  // there are far more than 100 players), just return 100.
  return 100;
}

int main(int argc, char* argv[])
{
  if (argc < 2)
  {
    std::cerr << "Missing score argument!\n";
    return EXIT_FAILURE;
  }

  try
  {
    scorevec past_scores = read_past_scores(argv[1]);

    std::srand(std::time(0));

    std::cout << generate_answer(past_scores) << std::endl;

    return EXIT_SUCCESS;
  }
  catch(std::exception& e)
  {
    std::cerr << e.what() << "\n";
    return EXIT_FAILURE;
  }
  catch(...)
  {
    std::cerr << "Unknown error\n";
    return EXIT_FAILURE;
  }
}

— celtschk
स्रोत

2

पर्ल (बॉब)

$_=<>;
INPUT:{

tr/ /,/;
@in = eval;
for(1..$#in){
 $bids[$rnum][$in[$_]]++
}
for(0..$#in){
 $tbids[$rnum][$in[$_]]++
}
$rnum++;
$_=<>;
if($_ ne"\n"){redo INPUT}
}

for(0..100){$pre[$_]=0}

blazer: {
for($r=1;$r<$rnum;$r++){
winner: for($pnt=1;$pnt<101;$pnt++){
        if($tbids[$r][$pnt] == 1){
            if($pnt > 2){
                $winnum[$pnt]++;
            $wins++;
            }
        last winner
        }
}
    }
    if($wins==0){
    $pre[3]++;last blazer
    }
}

CC1: for($pnt=1;$pnt<101;$pnt++){
    if($tbids[$rnum-1][$pnt] == 1){
        $pre[$pnt]++;last CC1
    }
}

CC2: for($pnt=1;$pnt<101;$pnt++){
    if($rnum-2<0){$pre[7]++;last CC2}
    if($tbids[$rnum-2][$pnt] == 1){
        $pre[$pnt]++;last CC2
    }
    if($pnt==100){
    $pre[7]++;last CC2
    }
}

one: {
$pre[1]+=2;
}

two: {
$pre[2]+=2;
}

five: {
$pre[5]+=2;
}

eight: {
$pre[8]+=2;
}

fortytwo: {
$pre[42]++;
}

mueller: {
    $a=($#in+2)/4;
    $pre[int$a]++;
}

schwarzenbeck: {
    $a=($#in+2)/4+1;
    $pre[int$a]++;
}

beckenbauer: {
    $a=($#in+2)/4+2;
    $pre[int$a]++;
}

totalbots: {
    $pre[$#in+1]++;
}

joe: {
$sum=0;
    for(1..100){
    $sum+=$_*$tbids[$rnum-1][$_];
}
    $average=$sum/($#in+1);
    if($average==0){$average=10};
    $pre[$average]++;
}

node: {
$max=0;$maxloc=0;
for(1..100){
    if($tbids[$rnum-1][$_]>$max){$max=$tbids[$rnum-1][$_];$maxloc=$_}
}
$maxloc--;
#if($maxloc==0){
$maxloc=20;
#}
if($rnum==1){$maxloc=3}
    $pre[$maxloc]++;
}
choice: for(1..100){
    if($pre[$_]==1){ 
$count++;
    if($count==3){print; last choice}
}
    if($_==100){print"98"}
}

"बॉब" देखें कि कैसे आह्वान किया जाए।

— PhiNotPi
स्रोत

यह मंगलाचरण के लिए एक बहुत ही पुनरावर्ती मार्गदर्शिका है ;-)

— गैरेथ

वास्तव में तर्क की एक श्रृंखला होती है: एलिस बताती है कि वह कैसे इनपुट लेती है। ईव ने उल्लेख किया कि वह ऐलिस के समान ही इनपुट लेता है। ईव ने यह भी उल्लेख किया है कि वह बॉब के समान ही इनपुट लेता है। इस प्रकार, बॉब ऐलिस के समान इनपुट प्रारूप लेता है, जिसका वर्णन किया गया है।

— PhiNotPi

2

पर्ल (एलिस)

$_=<>;
INPUT:{

tr/ /,/;
@in = eval;
for(1..$#in){
 $bids[$rnum][$in[$_]]++
}
for(0..$#in){
 $tbids[$rnum][$in[$_]]++
}
$rnum++;
$_=<>;
if($_ ne"\n"){redo INPUT}
}

for(0..100){$pre[$_]=0}

blazer: {
for($r=1;$r<$rnum;$r++){
winner: for($pnt=1;$pnt<101;$pnt++){
        if($tbids[$r][$pnt] == 1){
            if($pnt > 2){
                $winnum[$pnt]++;
            $wins++;
            }
        last winner
        }
}
    }
    if($wins==0){
    $pre[3]++;last blazer
    }
}

CC1: for($pnt=1;$pnt<101;$pnt++){
    if($tbids[$rnum-1][$pnt] == 1){
        $pre[$pnt]++;last CC1
    }
}

CC2: for($pnt=1;$pnt<101;$pnt++){
    if($rnum-2<0){$pre[7]++;last CC2}
    if($tbids[$rnum-2][$pnt] == 1){
        $pre[$pnt]++;last CC2
    }
    if($pnt==100){
    $pre[7]++;last CC2
    }
}

one: {
$pre[1]+=2;
}

two: {
$pre[2]+=2;
}

five: {
$pre[5]+=2;
}

eight: {
$pre[8]+=2;
}

fortytwo: {
$pre[42]++;
}

mueller: {
    $a=($#in+2)/4;
    $pre[int$a]++;
}

schwarzenbeck: {
    $a=($#in+2)/4+1;
    $pre[int$a]++;
}

beckenbauer: {
    $a=($#in+2)/4+2;
    $pre[int$a]++;
}

totalbots: {
    $pre[$#in+1]++;
}

joe: {
$sum=0;
    for(1..100){
    $sum+=$_*$tbids[$rnum-1][$_];
}
    $average=$sum/($#in+1);
    if($average==0){$average=10};
    $pre[$average]++;
}

node: {
$max=0;$maxloc=0;
for(1..100){
    if($tbids[$rnum-1][$_]>$max){$max=$tbids[$rnum-1][$_];$maxloc=$_}
}
$maxloc--;
#if($maxloc==0){
$maxloc=20;
#}
if($rnum==1){$maxloc=3}
    $pre[$maxloc]++;
}
choice: for(1..100){
    if($pre[$_]==1){ 
$count++;
    if($count==2){print; last choice}
}
    if($_==100){print"99"}
}

मेरे अन्य बॉट्स के समान इनपुट लेता है।

perl Alice.plx
1 4 3 12
3 2 4 11
[blank line]

— PhiNotPi
स्रोत

2

पर्ल (ईव)

मैंने इस प्रविष्टि को पूरी तरह से अपने अन्य बॉट्स के लिए मार्ग प्रशस्त करने में मदद करने के लिए बदल दिया।

$_=<>;
INPUT:{

tr/ /,/;
@in = eval;
for(1..$#in){
 $bids[$rnum][$in[$_]]++
}
for(0..$#in){
 $tbids[$rnum][$in[$_]]++
}
$rnum++;
$_=<>;
if($_ ne"\n"){redo INPUT}
}

for(0..100){$pre[$_]=0}

blazer: {
for($r=1;$r<$rnum;$r++){
winner: for($pnt=1;$pnt<101;$pnt++){
        if($tbids[$r][$pnt] == 1){
            if($pnt > 2){
                $winnum[$pnt]++;
            $wins++;
            }
        last winner
        }
}
    }
    if($wins==0){
    $pre[3]++;last blazer
    }
}

CC1: for($pnt=1;$pnt<101;$pnt++){
    if($tbids[$rnum-1][$pnt] == 1){
        $pre[$pnt]++;last CC1
    }
}

CC2: for($pnt=1;$pnt<101;$pnt++){
    if($rnum-2<0){$pre[7]++;last CC2}
    if($tbids[$rnum-2][$pnt] == 1){
        $pre[$pnt]++;last CC2
    }
    if($pnt==100){
    $pre[7]++;last CC2
    }
}

one: {
$pre[1]+=2;
}

two: {
$pre[2]+=2;
}

five: {
$pre[5]+=2;
}

eight: {
$pre[8]+=2;
}

fortytwo: {
$pre[42]++;
}

mueller: {
    $a=($#in+2)/4;
    $pre[int$a]++;
}

schwarzenbeck: {
    $a=($#in+2)/4+1;
    $pre[int$a]++;
}

beckenbauer: {
    $a=($#in+2)/4+2;
    $pre[int$a]++;
}

totalbots: {
    $pre[$#in+1]++;
}

joe: {
$sum=0;
    for(1..100){
    $sum+=$_*$tbids[$rnum-1][$_];
}
    $average=$sum/($#in+1);
    if($average==0){$average=10};
    $pre[$average]++;
}

node: {
$max=0;$maxloc=0;
for(1..100){
    if($tbids[$rnum-1][$_]>$max){$max=$tbids[$rnum-1][$_];$maxloc=$_}
}
$maxloc--;
#if($maxloc==0){
$maxloc=20;
#}
if($rnum==1){$maxloc=3}
    $pre[$maxloc]++;
}
choice: for(1..100){
    if($pre[$_]==1){ 
$count++;
    if($count==1){print; last choice}
}
    if($_==100){print"100"}
}

एक इनपुट प्रारूप लेता है: "बॉब" और "ऐलिस" के समान।

— PhiNotPi
स्रोत

1

Brainfuck

चुनौती से उद्धृत करने के लिए:

"आप जितने चाहें उतने बॉट्स में प्रवेश कर सकते हैं, इसलिए यदि कोई भी एक बॉट में प्रवेश करता है जो केवल अनुमान लगाता है 1, तो आप एक और दर्ज कर सकते हैं जो इसे बेकार करने के लिए एक ही करता है।"

खैर, जब से PhiNotPi ने एक दर्ज किया है , मुझे दूसरे में प्रवेश करने दें। बस अलग होने के लिए, मैं इसे Brainfuck में करूँगा:

+++[->++++<]>[-<++++>]<+.

बेशक, अब जब सट्टेबाजी 1 एक संभव रणनीति नहीं रह गई है, तो अब करने वाली स्पष्ट बात यह है कि इसके बजाय 2 दांव लगाना है ...

संपादित करें: दो प्रति टिप्पणियों में विभाजित उत्तर, दोनों कार्यक्रमों को अधिक दिलचस्प भाषाओं में फिर से लिखना।

— इल्मरी करोनें
स्रोत

सबसे पहले, प्रति उत्तर में एक प्रविष्टि। दूसरी बात, मुझे पता है कि कोई भी व्यक्ति हार न मानने की गारंटी के लिए 1 से 100 तक के अंकों में से प्रत्येक की छपाई के लिए 100 उत्तर दे सकता है - समान रूप से कोई और ठीक उसी अर्थ में कर सकता है कि कोई भी नहीं जीतेगा। फुटबॉल (सॉकर) के एक खेल में सभी 11 खिलाड़ी यह सुनिश्चित करने के लिए गोल लाइन पर खड़े हो सकते हैं कि दूसरी टीम स्कोर नहीं करती है। यह आम तौर पर इस तरह से कभी नहीं होता है क्योंकि यह एक खेल का ज्यादा होगा अगर वे ऐसा करते?

— गारेथ

तीसरा, इस आपत्ति को वास्तव में सैंडबॉक्स में उठाया जाना चाहिए था - आखिर इसका उद्देश्य क्या है।

— गारेथ

@ गैरेथ: ठीक है, मैंने उत्तर दो में विभाजित किया है। प्रविष्टियों की यथोचितता के लिए, आपने स्वयं यह सुझाव दिया है कि, यदि किसी को "अपुष्ट" प्रस्तुत करना है, तो कोई भी व्यक्ति इसका मुकाबला करने के लिए ऐसा कर सकता है। उस बिंदु पर, निश्चित रूप से, "ट्वॉस्कॉन्फ़िडेंट" को प्रस्तुत करना उतना ही समझ में आता है जितना कि "अपुष्ट" को पहले स्थान पर प्रस्तुत करना, इसलिए ...

— इल्मरी करोनन

1

इसके बारे में साफ-सुथरी बात यह है कि अब मैं इस प्रविष्टि को जीतने की अनुमति दिए बिना अपनी अपकमिंग प्रविष्टि को हटा नहीं सकता।

— PhiNotPi

1

@Peter: आपको ऐसा क्यों लगता है? यह देखते हुए कि मेरा और फ़िनोटपी के दोनों कार्यक्रम दौड़ में हैं, किसी और के पास कोई कार्यक्रम प्रस्तुत करने का कोई कारण नहीं है जो कभी भी 1 दांव लगाता है (यदि वे चाहते हैं कि कार्यक्रम जीतने के लिए, वह है)।

— इल्मरी करोनें

1

मुलर (स्काला)

object Mueller extends App {
  println ((args(0).split('\n')(0).split(' ').length+1)/4)
}

यदि आप श्वार्ज़ेनबेक और बेकेनबॉयर को जानते हैं, तो आप निश्चित रूप से मुलर से उम्मीद करते हैं। वह यहाँ है। वह बेकेनबॉएर और श्वार्ज़ेनबेक से बहुत लाभ उठाएगा और जीतने वाला है।

रनिंग और संकलन के बारे में विवरण: श्वार्जनबेक देखें

लक्ष्य के करीब, अब।

— अज्ञात उपयोगकर्ता
स्रोत

1

बेकेनबॉयर (स्काला)

object Beckenbauer extends App {
  println ((args(0).split('\n')(0).split(' ').length+1)/4+2)
}

श्वार्ज़ेनबेक की मदद से बेकेनबॉयर को कुछ गोल करने चाहिए। श्वार्जनबेक के बिना, वह कुछ भी नहीं है।

चलाने और संकलन के बारे में विवरण: देखें [श्वार्जनेबेक] [1]

संपादित करें: कमरे में अब और भी गहरे खेल रहे हैं।

— अज्ञात उपयोगकर्ता
स्रोत

1

बैच स्क्रिप्टिंग

echo 5

मेरा सबमिशन, हर बार इसके जवाब के रूप में 5; ;-)

— mellamokb
स्रोत

1

Eight.bat

echo 8

एक और सरल उत्तर, हर बार 8 देता है।

— mellamokb
स्रोत

1

FivesCancel (PHP)

रद्देल मेलमोकब का "हमेशा 5" समाधान।

— Ry-
स्रोत

1

EightsCancel (PHP)

कैंसेलोम्बॉक के "हमेशा 8" समाधान। क्षमा करें, मेलकमोक!

— Ry-
स्रोत

यहाँ हम फिर से चलते हैं, प्रतियोगिता: P

— mellamokb

1

पायथन 2.7 - Copycat2

प्रतियां दूसरा पिछले दौर के विजेता। अरे नहीं! अन्यथा आउटपुट 7।

import sys
content = sys.argv[1].split('\n')
x = map(int, content[-2].split()) if len(content) > 1 else [7]
y = []
for each in x:
    if x.count(each) == 1:
        y.append(each)
print min(y) if sum(y) > 0 else random.choice(x) if sum(x) > 0 else 7

— रंगीन जाकेट
स्रोत

1

शेल स्क्रिप्ट (डीप थॉट)

ठीक है, ताकि मुझे थोड़ा सा मौका मिले, यहां एक और प्रविष्टि, इस बार एक शेल स्क्रिप्ट (किसी भी शेल के साथ काम करना चाहिए)। यह हमेशा जीवन, ब्रह्मांड और सब कुछ के सवाल का जवाब देता है।

echo 42

वास्तव में यह एल्गोरिथ्म पूरी तरह से सही नहीं है क्योंकि मैंने 7.5 मिलियन वर्ष की देरी को छोड़ दिया था। :-)

— celtschk
स्रोत

आज रात के परीक्षण के लिए बहुत देर हो चुकी है क्षमा करें, लेकिन मैं सुबह एक और करूंगा।

— गारेथ

1

dirichlet.c

#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>

main(int argc, char* argv[])
{
    int handle;
    char *str;
    int32_t bits, val, n = 0;

    if (argc) {
        for (str = argv[1]; *str; str++)
            if (*str == 32) n++;
            else if (*str == 10) break;
    }

    n /= 2;
    if (n > 99) n = 99;

    handle = open("/dev/urandom", O_RDONLY);
    do {
        read(handle, &bits, sizeof bits);
        bits &= 0x7fffffff;
        val = bits % n;
    } while (bits - val + (n-1) < 0);
    close(handle);

    printf("%d", 2 + val);
}

मुझे लगता है कि यह यादृच्छिक बिट्स के माध्यम से बहुत तेजी से उपयोग होता है /dev/random , हालांकि मैं बहुत ज्यादा पसंद करूंगा। अगर कोई विंडोज पर इसका परीक्षण करना चाहता है, तो आपको इसे स्वयं पोर्ट करना होगा, क्योंकि मेरे पास सी कंपाइलर के साथ विंडोज बॉक्स तक पहुंच नहीं है।

दलील

मैं टूर्नामेंट खत्म होने से पहले इसके पीछे के तर्क को स्पष्ट नहीं करना चाहता था, लेकिन अब जब विजेता की घोषणा की गई है, तो मुझे लगता है कि यह समय है।

कबूतर-छेद सिद्धांत द्वारा (उर्फ डिरिचलेट के सिद्धांत, इसलिए बॉट का नाम), यदि एन प्रतिस्पर्धा वाले बॉट हैं, तो [1..1 + एन / 2] में एक नंबर डब्ल्यू है जो या तो जीता या अगर जीता होगा चयनित। इसलिए मैं निष्कर्ष निकालता हूं कि इष्टतम रणनीति 1+ एन / 2 से अधिक संख्या का चयन नहीं करेगी । लेकिन अगर N सम है, तो 1+ N / 2 का चयन करने से एक छोटा विजेता स्लॉट बनता है। इसलिए जो स्लॉट चुनने लायक हैं, वे [1 .. ( N) हैं +1) / 2] हैं।

यह सवाल छोड़ता है कि स्लॉट कैसे चुनें। बॉट की छोटी संख्या के लिए मैंने सत्यापित किया कि जब प्रत्येक बॉट उम्मीदवारों के बीच समान रूप से चयन करता है तो नैश संतुलन होता है, और मुझे दृढ़ता से संदेह है कि यह सही रहेगा।

सैद्धांतिक से इस बॉट की रणनीति में मामूली विचलन केवल पैमाइश है।

— पीटर टेलर
स्रोत

सबसे कम विशिष्ट बोली नीलामी

इनपुट

उत्पादन

स्कोरर कार्यक्रम

खिलाड़ियों का परीक्षण करें

विजेता

पर्ल

महाराज

पायथन (2.6)

अजगर (ब्लेज़र)

श्वार्जनेबेक (स्काला)

पर्ल

जावास्क्रिप्ट (नोड.जेएस)

अजगर (CopyCat)

अजगर (जो)

अजगर (TotalBots)

पर्ल (स्वास्थ्य निरीक्षक)

सी ++ (शिक्षित अनुमान)

पर्ल (बॉब)

पर्ल (एलिस)

पर्ल (ईव)

Brainfuck

मुलर (स्काला)

बेकेनबॉयर (स्काला)

बैच स्क्रिप्टिंग

FivesCancel (PHP)

EightsCancel (PHP)

पायथन 2.7 - Copycat2

शेल स्क्रिप्ट (डीप थॉट)

dirichlet.c

दलील