Subasta de oferta única más baja

22

Gracias por todas las entradas, la fecha límite ya pasó y los puntajes finales están al final de la pregunta.
Felicitaciones a PhiNotPi por una victoria bastante completa.

Este es un desafío del , cuyo objetivo es crear un programa que gane con más frecuencia que cualquiera de sus oponentes en una subasta de oferta única más baja.

Entrada

Como entrada, el programa recibirá todas las ofertas de rondas anteriores, una ronda por línea, todas las ofertas separadas por espacios de la siguiente manera:

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

Cada columna de la entrada representa la oferta de un bot. La primera columna son las ofertas del programa receptor, mientras que el resto está en un orden generado aleatoriamente. Gracias a hammar y Peter Taylor por su aporte.

La entrada se proporciona como el único argumento de línea de comandos (multilínea) para su programa:

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

Esto significa que su programa deberá ser ejecutable desde la línea de comandos. Dé un ejemplo de invocación como parte de su respuesta.

En la primera ronda solo como un medio para hacerle saber a cuántos bots se enfrenta, la entrada será una línea de0 s - uno para cada bot.

Salida

Su programa debe generar su oferta como un entero en el rango de 1 a 100 (inclusive).

Programa de anotadores

Este es mi programa de puntuación: cualquier sugerencia para adiciones, mejoras o correcciones de errores sería bienvenida.

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

Jugadores de prueba

Uno tiene confianza Siempre ofrece 1.

#include <stdio.h>

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

Random100 Ofertas al azar en todo el rango

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

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

Aleatorio 20 Ofertas al azar entre 1 y 20

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

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

Random5 Ofertas al azar entre 1 y 5

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

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

Ejemplo de ejecución:

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

Estos jugadores son solo para fines de prueba. NO serán incluidos en la competencia. Puede ingresar tantos bots como desee, por lo que si alguien ingresa un bot que solo adivina1 , puede ingresar otro que haga lo mismo para inutilizarlo.

Ganador

El bot ganador en cada ronda es el que ofrece la oferta única más baja . Entonces, dada una ronda en la que se realizan las siguientes ofertas: 1 1 3 5 2 3 6 3 2 8 7el ganador sería el bot que oferte 5porque los 1s, 2sy 3s no son únicos.

El ganador de la competencia será el programa que gane más veces después de 100 rondas. En caso de empate, el total de las ofertas ganadoras se usará como un desempate, y en el caso de que también sea un empate, la oferta ganadora más baja se usará como un desempate adicional. Todos estos factores de puntuación son producidos por el programa de puntuación.

Ejecutaré el programa de puntuación en todos los programas de trabajo que se hayan ingresado dentro de 2 semanas a partir de hoy (el 18 de febrero ahora se extiende hasta las 11 p.m. (GMT) del 20 de febrero ). Votaré todas las entradas en funcionamiento y aceptaré al ganador de mi carrera de puntuación.

Carrera final de puntuación

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
Gareth
fuente
1
Hmm ... con las reglas escritas tal como están, realmente podría estropear el juego al ingresar 100 programas que siempre ofrecen un número determinado.
Ilmari Karonen
1
¿Puedes decir dos oraciones, cómo se elige el bot ganador? No lo entiendo
usuario desconocido
@IlmariKaronen Eso es cierto, podrías. Pero estoy confiando en que la gente no hará eso. Supongo que podría limitar el número de entradas por persona, pero creo que solo recurriré a eso si aparecen algunos spoilers.
Gareth
@userunknown He tratado de aclarar cómo funcionan las rondas de subastas.
Gareth
1
@PhiNotPi: No te sientas culpable. Ganaste dentro de las reglas.
Steven Rumbalski

Respuestas:

9

Perl

Lo intenté un poco más esta vez. Es un muy simple estrategia compleja, pero he configurado el marco para la expansión.

Editar: completa rehacer. Esta cosa está ahí para la victoria.

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

Este programa toma la entrada de una línea a la vez, seguida de dos nuevas líneas:

perl PhiNotPi2.plx
1 2 3 3 2
2 1 3 1 3
2 1 1 1 3
[empty line]
PhiNotPi
fuente
Ok, esto lleva el metagaming a los extremos.
Peter Taylor
@petertaylor ¿Me estoy yendo demasiado fuera de línea? ¿Debo volver a mi original?
PhiNotPi
2
Este es un sitio conocido por los abogados de reglas: es perfectamente justo. Pero estoy llegando a la conclusión de que el mecanismo de intercambio de stack podría no ser el mejor para las competiciones del rey de la colina.
Peter Taylor
También he llegado a esa conclusión. Necesitamos crear un método para ocultar los bots de la vista en futuras competiciones. Por lo que sé, alguien está haciendo metagaming contra mis bots en este momento.
PhiNotPi
Lol, esta fue mi idea: P. Como ya lo implementó, y me siento flojo, lo dejaré tener :) Tenga en cuenta que el único tipo de entrada que esto no puede vencer fácilmente son las que implementan aleatoriedad
mellamokb
8

Cocinero

Como siempre apostar 1 es ahora una estrategia perdedora , lo obvio es apostar siempre 2 . Entonces déjame hacer eso. Para hacer que esta entrada aburrida fuera un poco más interesante, decidí escribirla en Chef :

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.

Como beneficio adicional, el programa en realidad funciona más o menos como una receta real, aunque trivial, incluso si se lee como si el escritor estuviera un poco, um, horneado. La gramática del Chef parece hacer que sea bastante difícil escribir algo que involucre algo más complicado que mezclar cosas en un tazón y hornearlo y aún así hacerlo funcionar como un programa y como una receta, especialmente si alguno de los verbos que uno quiere usar son incluso ligeramente irregulares (como "alevines" → "fritos").

Editar: cambió la receta de frito a fruncidas huevos - gracias a la chaqueta por la sugerencia! El tiempo y la temperatura de cocción deben considerarse solo informativos; Todavía no he probado la receta, así que no puedo garantizar su precisión.

Ilmari Karonen
fuente
Creo que esto genera 1: vea mi comentario en codegolf.stackexchange.com/a/4851 .
msh210
Produce 2, al menos utilizando el intérprete Acme :: Chef . El bucle final está ahí solo para ofuscar, y para que los comensales no tengan que comer los huevos crudos.
Ilmari Karonen
Ah, claro, extrañé el hecho de que los huevos ya estaban en la fuente para hornear y que eso no es lo que está disminuido.
msh210
2
Lo llamas shirred eggs, que en realidad se hace en una fuente para horno y eso haría que la receta sea una receta de cocina válida y gramaticalmente correcta. shirr the eggs. shirr the eggs until shirred.¡Horray por tener educación culinaria en mi haber! :)
Blazer
1
el tiempo de cocción / temperatura parece correcto :). por supuesto, siempre utilícelos solo como pautas, ya que es el chef quien determina si se hace algo o no, ¡no el tiempo / temperatura en sí mismo!
Blazer
4

Python (2.6)

Extremadamente simple, pero aún tengo curiosidad por saber cómo funcionará en comparación con los otros enfoques.

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)

Simplemente ingrese las ofertas a través de stdin, por ejemplo python testbid.py < bids.txt.

EDITAR : cambiado para la 'primera ronda todos ceros'

EDITAR : cambió un poco los 'números mágicos' (una segunda vez)

ChristopheD
fuente
1
no debería m = random.choice(1,2,2,3,3,3)ser m = random.choice([1,2,2,3,3,3])?
Blazer
Lanzó un error donde Blazer dijo que podría. He puesto entre corchetes para la prueba y parece haber funcionado.
Gareth
@Blazer: sí, absolutamente (pequeño error tipográfico de mi parte). Gracias por avisar
ChristopheD
4

Python (Blazer)

Este bot analiza las rondas anteriores y registra los números que ganan. Por lo tanto, los números ganadores que aparecen con más frecuencia tendrán una mejor oportunidad de ser seleccionados. Luego elegirá al azar los números de los números ganadores (que no sean 1 o 2). elegirá 2 3 si es la primera ronda.

La entrada se lee una línea a la vez. simplemente ingrese una línea vacía para dejar de aceptar entradas

Un truco es simplemente pegar (acepta automáticamente cada línea con \ n dentro del pegado) y presionar enter dos veces

Ahora puede ejecutar el script con un nombre de archivo en la línea de comando:

python bidding.py bidding.txt

el archivo debería verse así:

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)

editar: agregado or sum(rounds) == 0para compensar el reciente cambio de primera ronda de todos ceros

editar: se corrigieron problemas en los comentarios, también permitió recibir información de un nombre de archivo, y ya nunca elige '2' ya que la competencia también lo eliminó. funciona con todos los 0 como entrada inicial o sin datos en el archivo

edit2: olvidé un min ()

edit3: entrada modificada para adaptarse a las necesidades de entrada de la pregunta

Chaqueta de sport
fuente
Causa un pequeño problema con el anotador: tengo que presionar enter para obtener el puntaje de cada ronda. No es un gran problema para mis 10 rondas de prueba, pero podría ser un dolor para las 100 rondas.
Gareth
@Gareth, envuélvelo en un script bash. echo "$@" | python bidding.pyDebería hacer el trabajo.
Peter Taylor
He intentado esto como Peter sugirió, pero recibo un error TypeError: unsupported operand type(s) for +: 'int' and 'list'para la línea 23. Estoy usando Python 2.6.1, ¿es ese el problema? ¿Necesito una versión más nueva? Me sale el mismo problema sin usar el script bash.
Gareth
@Gareth, ¿ayudaría si lo hiciera para que la entrada se canalice desde sys.argv [1] con un nombre de archivo?
Blazer
@Blazer No estoy seguro de que ese sea el problema. Estoy llamando al programa desde la línea de comandos usando mi invocación de ejemplo y obteniendo el error que di anteriormente. ¿Hay algo allí que sea incompatible con Python 2.6.1?
Gareth
3

Schwarzenbeck (Scala)

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

Se supone que Schwarzenbeck no marca los goles. Él es la limpieza de Beckenbauer, que sigue pronto. :)

Para usarlo, necesitas un compilador y compilarlo

scalac Schwarzenbeck.scala 

Entonces puedes ejecutarlo:

scala Schwarzenbeck 'your ar-
gu-
ment' 

Editar: ajustes adicionales.

usuario desconocido
fuente
1
Dado que se suponía que Schwarzenbeck no marcaría los goles, diría que falló por completo :-)
celtschk
Sí, tenía un dilema: hice una línea de 3 jugadores y esperaba que Müller anotara la mayor cantidad de puntos, pero desde una posición estratégica, Schwarzenbeck marcó la última línea de defensa. El metafer del fútbol falló, ya que mi línea de defensa marcó los goles. :)
usuario desconocido
3

Estratega (Ruby)

Implementa cientos de estrategias simples: para cada ronda, elige la que hubiera ganado la mayoría de las rondas anteriores:

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]

No estoy seguro de tener el formato de entrada correcto: no estoy seguro de cómo generar argumentos de línea de comandos de varias líneas para probarlo en Windows. (Este método parece funcionar en IDEone).

AShelly
fuente
No puedo probarlo ahora, estoy en el trabajo y no estaré en casa hasta después de las 9.30 (GMT). ¿Esta pregunta SO ayuda con los argumentos de varias líneas?
Gareth
Acabo de probar esto y me está dando un error 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). Dejaré de considerar nuevas entradas después de las 11 p.m., pero retrasaré un poco la ejecución de la puntuación para darle tiempo para ver el error si lo desea.
Gareth
Bien, creo que el problema era que tenías en ARGFlugar de ARGV. Después de hacer ese cambio, el programa adivina 1cada vez. ¿Alguna idea de lo que puedo hacer para solucionarlo?
Gareth
¿Puede agregar esta línea en la parte superior y decirme qué imprime cuando le da la entrada de la segunda ronda (2 líneas de datos): p ARGV.map{|l|l};exit (Ninguna de las respuestas SO a la pregunta que hace referencia o similares parecen darme la entrada esperada)
AShelly
Se imprime ["1 2\n3 4\n5 6\n1 2"]para la entrada de prueba en la pregunta.
Gareth
2

Perl

Pensé que bien podría entrar en lo inevitable. Más entradas serias próximamente. Como beneficio adicional, esta entrada nunca perderá en una competencia uno a uno.

print 1
PhiNotPi
fuente
No ganar todas las competiciones. en un uno contra uno con otro seguro, empatará
Blazer
¡No! ¡No puedo creer que me haya olvidado de ese caso! Lo arreglaré
PhiNotPi
Una de mis conclusiones cuando comencé a diseñar mi entrada es que cada bot debe enviar 1 al menos 1 / n de las veces, para hacer su parte justa para evitar que los confidentes se vayan con ella.
Peter Taylor
@ Peter: No te preocupes, me encargué de eso . :)
Ilmari Karonen
2

JavaScript (node.js)

Cuenta lo que fue más popular en la última ronda y ofrece uno menos que eso, ajustando a 20 y ofreciendo 3 en la primera ronda.

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

Cómo invocar:

node script.js 'the argument'
Ry-
fuente
Mirando los resultados de la ejecución de prueba más reciente, esto no se comporta como se documenta. ¿Alguna idea de por qué no?
Peter Taylor
1
@PeterTaylor Me pregunto si es el primer forbucle. ¿Deberías if(i in numbers)estarlo if(matches[i] in numbers)?
Gareth
@minitech Después de hurgar un poco, parece que la expresión regular solo coincide con el número de la entrada; sin embargo, no sé lo suficiente sobre JavaScript o Nodejs para poder decir por qué. Además, ¿necesita dividir la entrada en las nuevas líneas para obtener la última ronda?
Gareth
@Gareth: De hecho lo es. Actualizado, aunque si funcionó mejor originalmente, entonces no me importa :)
Ry-
Desafortunadamente, arroja un error para cada ronda, excepto la primera ahora: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)
Gareth
2

Python (CopyCat)

Otro más, esta vez copia la respuesta exacta que tuvo el último ganador, si hubiera una. Está diseñado para intentar ganar y bloquear a otros postores. puja 5si la primera ronda, puja un número aleatorio de la ronda anterior si de alguna manera no hubo ganador

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
Chaqueta de sport
fuente
2

Python (Joe)

De ninguna manera está diseñado para ganar, pero de todos modos lo estoy lanzando para agregar algo de color a la multitud :) Ofrece el promedio de la última ronda (Joe promedio). Invocado lo mismo que mi respuesta original (que ahora nombraré porque parece que eso es lo que están haciendo todos los niños geniales, y ayuda a distinguir los dos). si comienza la ronda, hace una oferta 10.

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

editar: método de entrada modificado para adaptarse al método de entrada de la pregunta

Chaqueta de sport
fuente
2

Python (TotalBots)

Creo que este será el último, pero ya veremos. Aprovecha la ventaja de saber cuántos bots hay simplemente generando el número de bots competidores, por lo que si hay 17 bots (número actual de bots, más este), generará17

content = sys.argv[1].split('\n')
print len(content[-1].split())
Chaqueta de sport
fuente
2

Perl (inspector de salud)

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

Apuesto a que puedes adivinar lo que hace.

PhiNotPi
fuente
2

C ++ (conjetura educada)

Ya pensé que habría pasado la fecha límite, pero gracias a la extensión aún puedo agregar mi entrada. Este programa compila con g ++. El programa intenta adivinar las estadísticas de las otras entradas y elegir la más pequeña que probablemente no sea elegida por ninguna otra.

#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
fuente
2

Perl (Bob)

$_=<>;
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"}
}

Ver "Bob" para saber cómo invocar.

PhiNotPi
fuente
Esa es una guía muy recurrente para la invocación ;-)
Gareth
En realidad, se ha establecido una cadena de lógica: Alice describe cómo toma la información. Eve menciona que ella toma la misma entrada que Alice. Eve también menciona que ella toma la misma entrada que Bob. Por lo tanto, Bob toma el mismo formato de entrada que Alice, que se describe.
PhiNotPi
2

Perl (Alice)

$_=<>;
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"}
}

Toma datos similares a mis otros bots.

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

Perl (Eva)

Rehice completamente esta entrada para ayudar a allanar el camino para mis otros bots.

$_=<>;
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"}
}

Toma un formato de entrada: el mismo que "Bob" y "Alice".

PhiNotPi
fuente
1

Brainfuck

Para citar el desafío:

"Puede ingresar tantos bots como desee, por lo que si alguien ingresa un bot que solo adivina 1, puede ingresar otro que haga lo mismo para que sea inútil".

Bueno, como PhiNotPi ingresó uno , déjame ingresar otro. Para ser diferente, lo haré en Brainfuck:

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

Por supuesto, ahora que apostar 1 ya no es una estrategia factible, lo más obvio ahora es apostar 2 ...

Editar: divide la respuesta en dos por comentarios, reescribió ambos programas en idiomas más interesantes.

Ilmari Karonen
fuente
En primer lugar, una entrada por respuesta, por favor. En segundo lugar, sé que alguien podría publicar 100 respuestas imprimiendo cada uno de los dígitos del 1 al 100 para garantizar que no pierda; igualmente, otra persona podría hacer exactamente lo mismo que nadie ganará. En un juego de fútbol (soccer), los 11 jugadores podrían pararse en la línea de gol para garantizar que el otro equipo no anote. Normalmente nunca sucede de esa manera porque sería un gran juego si lo hicieran, ¿verdad?
Gareth
En tercer lugar, esta objeción realmente debería haberse planteado en la caja de arena , después de todo, ese es su propósito.
Gareth
@Gareth: OK, he dividido la respuesta en dos. En cuanto a la razonabilidad de las entradas, usted mismo sugirió que, si alguien presentara "unos confiados", alguien más podría hacer lo mismo para contrarrestarlo. En ese punto, por supuesto, presentar "dos confidentes" tiene tanto sentido como presentar "unos confidentes" en primer lugar, así que ...
Ilmari Karonen
1
Lo bueno de esto es que ahora no puedo eliminar mi entrada segura sin permitir que esta entrada gane.
PhiNotPi
1
@ Peter: ¿Por qué piensas eso? Dado que tanto los programas míos como los de PhiNotPi están en carrera, no hay razón para que alguien más presente un programa que alguna vez apueste 1 (si quieren que ese programa gane, eso es).
Ilmari Karonen
1

Mueller (Scala)

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

Si conoces a Schwarzenbeck y Beckenbauer, seguramente esperabas a Mueller. Aquí está él. Se beneficiará mucho de Beckenbauer y Schwarzenbeck y se supone que gana.

Detalles sobre el funcionamiento y la compilación: ver Schwarzenbeck

Más cerca de la meta, ahora.

usuario desconocido
fuente
1

Beckenbauer (Scala)

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

Con la ayuda de Schwarzenbeck, se supone que Beckenbauer marca algunos goles. Sin Schwarzenbeck, él no es nada.

Detalles sobre la ejecución y la compilación: Ver [Schwarzenbeck] [1]

Editar: Jugar más profundo en la sala ahora, también.

usuario desconocido
fuente
1

Scripting por lotes

echo 5

Mi presentación, da 5 como respuesta cada vez ;-)

mellamokb
fuente
1

Ocho.bat

echo 8

Otra respuesta simple, da 8 cada vez.

mellamokb
fuente
1

FivesCancel (PHP)

Cancela la solución "siempre 5" de mellamokb.

5
Ry-
fuente
1

EightsCancel (PHP)

Cancela la solución "always 8" de mellamokb. Lo siento, mellamokb!

8
Ry-
fuente
Aquí vamos de nuevo, competencia: P
mellamokb
1

Python 2.7 - Copycat2

Copia el ganador de la segunda última ronda. ¡Oh no! de lo contrario salidas 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
Chaqueta de sport
fuente
1

Script de Shell (pensamiento profundo)

OK, para que tenga una pequeña segunda oportunidad, aquí hay otra entrada, esta vez un script de shell (debería funcionar con cualquier shell). Esto siempre da la respuesta a la pregunta de la vida, el universo y todo.

echo 42

En realidad, este algoritmo no es del todo correcto porque omití el retraso de 7,5 millones de años. :-)

celtschk
fuente
Demasiado tarde para la prueba de esta noche, lo siento, pero haré otro por la mañana.
Gareth
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);
}

Creo que esto pasa por bits aleatorios demasiado rápido para usar /dev/random, por mucho que prefiera. Si alguien quiere probarlo en Windows, tendrá que portarlo usted mismo, porque no tengo acceso a un cuadro de Windows con un compilador de C.

Razón fundamental

No quería explicar la lógica detrás de esto antes de que terminara el torneo, pero ahora que se ha anunciado el ganador, creo que es hora.

Según el principio del agujero de paloma (también conocido como el principio de Dirichlet, de ahí el nombre del bot), si hay N bots competidores, entonces hay un número w en [1..1 + N / 2] que ganó o habría ganado si seleccionado. Por lo tanto, concluyo que la estrategia óptima no seleccionará números mayores que 1+ N / 2. Pero si N es par, seleccionar 1+ N / 2 crea una ranura ganadora más pequeña. Por lo tanto, los espacios que vale la pena seleccionar son [1 .. ( N +1) / 2].

Eso deja la pregunta de cómo seleccionar una ranura. Para un pequeño número de bots, verifiqué que hay un equilibrio de Nash cuando cada bot selecciona de manera uniforme entre los candidatos, y sospecho firmemente que esto seguirá siendo cierto.

La desviación menor en la estrategia de este bot de la teórica es simplemente metagaming.

Peter Taylor
fuente