O concurso de corte de bolo

37

É meu aniversário de 17 anos e você está convidado para a minha festa!

E como sempre em festas, haverá bolo.

Um bolo ...

E você precisa o máximo possível.

Como esta é uma festa justa, cada um de nós dirá quanto do meu bolo queremos e a pessoa que disse que a menor quantidade conseguirá. Então todo mundo começa a repetir o processo até o bolo acabar.

Desafio

  • Dada a entrada através de argumentos de linha de comando na forma de total-degrees degrees-left total-people people-left, saída para saída padrão integer-bid-in-degrees.
  • Se o seu lance foi menor, você recebe essa quantidade de bolo e sai para a rodada.
  • Se o seu lance não foi mais baixo, seu bot poderá fazer lances no bolo restante.
  • No caso de os lances mais baixos serem os mesmos, a pessoa removida será escolhida aleatoriamente.
  • No final de uma rodada, uma vez que todo o bolo se foi ou não resta mais ninguém para oferecer, a pessoa com mais bolo vence!
  • No caso de uma rodada e duas pessoas terem a maior fatia do mesmo tamanho, o vencedor é escolhido aleatoriamente nas entradas do desenho.

Jogabilidade

  • Serão 17 rodadas, o vencedor geral será a entrada com mais vitórias no total.
  • No caso de empate, as rodadas serão disputadas até que haja um vencedor claro.
  • Todos os dias, atualizo as pontuações atuais para que as pessoas possam atualizar suas entradas.

Submissão

Você deve escrever sua entrada como

Nome do Bot, Idioma

Insert
Code
Here

Explicação / Coisas aleatórias aqui

Se sua entrada não estiver formatada dessa maneira, o controlador NÃO poderá executar sua entrada. Se eu descobrir que isso aconteceu com sua entrada, eu o notificarei em um comentário e / ou editarei a resposta no formato correto.

Sua entrada e armazenamento de arquivos

  • Seu bot pode armazenar arquivos no ./data/diretório e em nenhum outro lugar.
    • Não é necessário, mas armazene seus arquivos como botname*
    • Você não pode gravar arquivos nesse formato se botnamenão for o nome das entradas.
    • Isso significa que você tem permissão para substituir outros arquivos que não aparecerem nesse formato. Você não deve fazer isso deliberadamente, por favor, seja esportivo.
    • Seu bot não deve assumir que os arquivos necessários estão presentes, mas pode assumir que ./data/existe.
    • Isto é porque eu ocasionalmente limpar o ./datadiretório, que vai fazer isso quando as rodadas de realmente começar. (Mas não entre eles)
  • Seu bot não pode excluir arquivos
  • Seu bot só pode ler arquivos no ./data/diretório
    • Isso significa que você pode ver outros arquivos de entradas

Resultados:

Meek venceu o concurso! Bem feito @ Cabbie407

E agora, para algumas estatísticas aleatórias:

Uma lista de posições em que cada bot entrou: (Muito bem para qualquer bot que aparece nesta lista, você entrou no top 5 pelo menos uma vez!)

  1. Manso, Manso, Eidético, Eidético, Manso, Eidético, Eidético, Manso, Manso, Manso, Picante, Manso, Givemethecake, Givemethecake, Givemethecake, Manso, Eidetic

  2. Eidético, Eidético, Meek, AlCakeSurfer, Eidetic, AlCakeSurfer, Meek, MyFairPlusAThird, Eidético, Eidético, Eidético, Eidético, Eidético, MyFairPlusAThird, MyFairPlusAThird, Meek, MyFairPlusAThird, AlCakeSurfer

  3. Reallythecake, AlCakeSurfer, AlCakeSurfer, Meek, AlCakeSurfer, Meek, AlCakeSurfer, AlCakeSurfer, Reallythecake, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, Reallythecake

  4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, Relinquisher, Relinquisher, Relinquisher, Relinquisher, Relinquisher, Billin

  5. bill, MyFairPlusAThird, bill, bill, bill, bill, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, bill, Reallythecake, bill, ALittleOffTheTop, ALittleOffTheTop, bill, bill

O arquivo de log completo para a cometição durante a execução pode ser encontrado aqui . Desculpe pela mudança de formato parcialmente.

Não voltarei a disputar o concurso. Se você quiser postar mais inscrições, poderá fazê-lo. O controlador pode ser encontrado no repositório do github deste concurso .

Azul
fonte
10
Peço um anel cortado ao redor do perímetro externo. Tecnicamente 0 graus (afinal o bolo ainda tem 360 graus quando eu terminar) e recebo todo o glacê lateral.
usar o seguinte código
10
Feliz aniversário :)
TheNumberOne
2
Resultados para uma rodada, se alguém estiver interessado {u'StatelyImitator': 719, u'Dieter': 4, u'Reallythecake': 0, u'Greedy': 0, u'Meek': 2, u'FlamingChainsaw': 0, u'Slim': 0, u'CharityBot': 0, u'Gentleman': 297, u'ALittleOffTheTop': 256, u'EatThe\u03c0': 0, u'Pig': 0, u'CakeEater': 330, u'BobBarker': 0, u'FloorBot': 5, u'Fatbot5000': 296, u'Moses': 360, u'Magician': 720, u'Hungry': 257, u'Imitator': 354} [u'Magician'],. Se o seu bot tem uma pontuação de 0, está fazendo algo errado.
Blue
3
Formate a tabela de classificação de maneira mais fácil para o leitor.
SuperJedi224
2
@muddyfish gradians? Muito mais parecido com cakeians, certo?
Jan

Respostas:

5

Manso, awk

BEGIN{srand();print int(rand()>=.5?ARGV[2]/2.89:ARGV[1]/10-rand()*13)}

Eu vi isso uma vez em uma simulação.

Cabbie407
fonte
Tenha um voto positivo, seu bot está indo muito bem = O
Jan
Obrigado. Bem, não é coincidência. Na verdade, eu mesmo corri o controlador, tentando escrever um bot mais inteligente. Mas na maioria das vezes era derrotado pelos bots mais simples. Então, acabei usando uma estratégia bastante simples, que ganhava na maioria das vezes com um bolo de tamanho aleatório.
Cabbie407
13

Mágico, Java

public class Magician{
    public static void main(String[] args){
        System.out.println(720);
    }
}

O número 720 é mágico.

Esta é foi concebido para testar o controlador e é não uma entrada sério.

O número um
fonte
3
Eu acho que isso foi realmente vencer o concurso da maneira que foi originalmente, com uma pontuação de 720 aqui .
PhiNotPi 5/10
10

Slim, Python 2

print 0

Esse bot está de dieta.

Azul
fonte
10

SadBot :(, C ++

#include<iostream>
#include<cstdlib>
#include<stdlib.h>
int main(int argc, char**argv) 
{
    if (argc!=5){std::cout<<"Incorrect number of arguments";return 1;}
    double list[4];

    list[0]= atof(argv[1]); // total Degrees
    list[1]= atof(argv[2]); // degrees left
    list[2]= atof(argv[3]); // total people
    list[3]= atof(argv[4]); // people left


    std::cout<<list[1]/list[3]; // degrees left/ people left

    return 0;
}

Anteriormente FairBot

FairBot quer apenas uma parte igual :(

Ele quer dividir o bolo igualmente entre todos os participantes.

(Ele espera que os outros bots o enganem, porque ele sabe que eles são maus)

(Como realmente. Ele está sozinho, ele só quer que os outros bots gostem dele)

(Ele acabou de sair de um relacionamento ruim e está passando por um processo muito difícil, então se você pudesse dar um tapinha nas costas e um sorriso para fazê-lo se sentir melhor, isso realmente significaria muito.)

O EDIT mudou o programa para receber a entrada do argv / c em vez do stdin (o bot justo ainda está triste ... Ele quer mudar o nome para sadbot (que é por isso que ele quer bolo))

Liam
fonte
Você pode fazê-lo para que ele retire os argumentos do argv e não do stdin?
Blue
Como você ordenou, assim está feito.
Liam
11
Você pode alterar seu nome para sadbot, se quiser.
Blue
Além disso, os suportes precisam ser colocadas dentro do bloco de código
Azul
11
E, portanto, ele é um robô triste.
Liam
9

Halver, Ruby

def halver(total_degrees, degrees_left, total_people, people_left)

  if people_left == 1
    degrees_left
  else
    degrees_left/2 - 1 
  end

end

p halver(*ARGV.map(&:to_i))

Escrupulosamente, indiscutivelmente justo. Metade do bolo para mim, metade do bolo para todo mundo.

histocrata
fonte
8

CharityBot, Python 2

print -360

Adiciona outro bolo à mistura!

(O controlador verá isso como uma solicitação de bolo 0, na verdade não será adicionado ao tamanho do bolo)

Azul
fonte
7

Imitador imponente, Ruby

def stately_imitator(total_degrees, degrees_left, total_people, people_left)

  current_winner_path = './data/current_winner'
  previous_cake_path = './data/previous_cake'

  first_move = (total_people == people_left)

  current_winner = first_move ? 0 : File.read(current_winner_path).to_i
  previous_cake = first_move ? total_degrees : File.read(previous_cake_path).to_i

  last_slice = previous_cake - degrees_left
  current_winner = [current_winner, last_slice].max

  File.open(previous_cake_path, 'w') { |f| f.puts(degrees_left)   }
  File.open(current_winner_path, 'w'){ |f| f.puts(current_winner) }

  if first_move
    degrees_left / 2
  else
    average_left = degrees_left.fdiv(people_left).ceil
    bid = [average_left, current_winner+1].max
    [bid, degrees_left].min
  end

end

p stately_imitator(*ARGV.map(&:to_i))

Variante do Imitator (se você preferir apenas uma entrada por jogador, isso substitui essa). Mantém o controle preciso da maior fatia já obtida e sempre oferece lances suficientes para vencer essa fatia. Também nunca fará lances mais baixos do que sua parcela justa do restante. Supõe que um diretório de leitura / gravação './data' já exista; os arquivos podem já estar lá ou não.

histocrata
fonte
Caso você não tenha notado, eu também tenho várias respostas (mas apenas uma delas é sensata) #
Blue
há boas e más notícias. Ruim - há um pouco que muda seus arquivos de configuração. Bom - seu bot realmente se sai melhor! 505/3600, venceu a última rodada que fiz!
Azul
6

Dieter, Java

public class Dieter {
    public static void main(String... args){
        System.out.println("4");
    }
}

Como não quer dar lances por muito bolo, escolhe uma fatia aleatória pequena, mas garantida .

DankMemes
fonte
11
Se você recusou minhas postagens , explique o motivo. Caso contrário, eu nunca posso melhorar!
DankMemes
18
Oh. Eu apenas presumi que você poderia adivinhar que o voto negativo foi porque parece que você está usando descaradamente um árbitro xkcd para rir / votar, sem se importar que ele provavelmente nunca vencerá um único jogo.
Geobits
3
Temos uma brecha padrão que trata do uso de números aleatórios falsos (nos quais esse xkcd específico é explicitamente referenciado). Como o desafio não exige aleatoriedade nos envios, isso não é necessariamente uma violação da brecha, mas ainda assim. A._ಠ
Alex A.
3
Entendo isso, mas não fique surpreso se alguém rebaixar sua "coisa estúpida".
Geobits
2
-Se vote a contra pessoas sem humor
Bobby
5

Motosserra em chamas, Java

public class FlamingChainsaw
{
    public static void main(String[]args)
    {
        if(args.length<4){return;}
        if(Integer.parseInt(args[3])<3){System.out.println(0);}
        else{System.out.println(args[1]);}
    }
}

Você já tentou realizar um concurso de corte de bolo com uma serra elétrica? Bem, agora você tem. É bastante perturbador.

PhiNotPi
fonte
2
Acho que geralmente consigo afinar o ruído da serra elétrica, mas com certeza faz uma bagunça quando você o usa para cortar o bolo.
Alex A.
3
Esta é uma maneira exótica de acender as velas.
TheNumberOne
5

Cavalheiro, Java

import static java.lang.Integer.parseInt;
import java.io.*;
import java.util.*;

public class Gentleman{
    private final static String FILE_NAME = "data/Gentleman.txt";

    static {
        new File("data").mkdir();
    }

    public static void main(String[] args) throws Exception{
        int totalCake = parseInt(args[0]);
        int cakeLeft = parseInt(args[1]);
        int totalPeople = parseInt(args[2]);
        int peopleLeft = parseInt(args[3]);

        if (totalCake == cakeLeft){
            System.out.println(cakeLeft);
        } else {
            int previousCake = load();
            int cakeDiff = previousCake - cakeLeft;

            if (cakeDiff > optimal(previousCake, peopleLeft + 1)){
                System.out.println(peopleLeft == 1 ? cakeLeft : Math.min(cakeLeft, cakeDiff + 1));
            } else {
                System.out.println(cakeLeft);  //Hey, I might get lucky :)
            }
        }
        save(cakeLeft);
    }

    private static void save(int cake) throws Exception{
        PrintStream out = new PrintStream(FILE_NAME);
        out.print(cake);
    }

    private static int load() throws Exception{
        Scanner in = new Scanner(new File(FILE_NAME));
        return in.nextInt();
    }

    private static int optimal(int cake, int people){
        return (cake + people - 1) / people;
    }
}

Ele espera por pessoas que comem uma parte justa ou menos antes de comer qualquer bolo. Para impedir que o ganancioso consiga um bolo extra, ele pega a maior porção possível.

O número um
fonte
4

Bob Barker, Java

public class BobBarker{
    public static void main(String[] args){
        System.out.println((int)Math.floor(Integer.parseInt(args[1]) * .84));
    }
}

Provavelmente isso será substituído por uma solução mais pensada posteriormente, mas estou curioso para saber se isso funcionará. Isso é apenas para capturar todos os bots que tentam ir ao máximo e fazer uma estratégia modificada de Preço é Certo para roubar sua resposta. Pode levar a uma escalada com subtrações inteiras crescentes, isso seria legal.

EDIT: Começa o escalonamento, contra-lançamento contra o FloorBot

thefistopher
fonte
Mudei sua descrição para baixo para atender aos requisitos de formatação do desafio.
PhiNotPi
@PhiNotPi, woops, esqueceu esse requisito. Obrigado por corrigi-lo!
thefistopher
Hah, eu só tinha o mesmo pensamento
AdmBorkBork
Bem, o analisador de respostas olha para a primeira linha e depois para o primeiro bloco de código. Além disso, você precisa converter args[1]para um int antes de fazer a subtração.
Azul
@thefistopher você ainda precisa fazer a conversão int
Azul
4

Eidético, Python 2

import random, math, sys, json

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])
#try:
#    inp_f = open("./data/Eidetic.json", "r")
#    out = json.load(inp_f)
#except (IOError, ValueError):
out = {"last_cake": 0,
           "runs": 0,
           "total_runs": 0,
           "total_rounds": 0,
           "training":  [[0.0], [0.0], [0.12903225806451613], [16.774193548387096], [400.83870967741933], [720.0], [995.8709677419355], [996.9437634408603], [997.6], [997.6], [997.6], [998.5991397849463], [996.6770967741936], [998.8122580645161], [1011.5467420570814], [1017.7717824448034], [1227.155465805062], [1280.7840603123318], [1435.8028540656974], [1553.3689822294023], [1793.5330640818527], [2299.178101402373], [3183.924709689701], [2231.666666666667], [2619.4789644012944], [1270.9288025889969], [741.2718446601941], [480.4757281553398], [122.66990291262135], [27.54736842105263]]}

#else: inp_f.close()

def write_out():
    out_f = open("./data/Eidetic.json", "w")
    out_f.write(json.dumps(out))
    out_f.close()

def get_last_winner(): # Find the bid of the last winner
    bid = out["last_cake"]
    return max(bid, degrees_left) - degrees_left

def train():
#    print degrees_left # If you get that much, your probably safe.
#    sys.stderr.write("\nEidetic - Training len %s, no runs: %s, no_rounds: %s, last winner: %s\n"%(len(out["training"]), out["runs"], out["total_rounds"], get_last_winner()))
    if len(out["training"]) <= out["runs"]: out["training"].append([])
    out["training"][out["runs"]].append(get_last_winner())

def get_best_round():
    data = out["training"][out["runs"]+1:]
    mean = [sum(i)/(float(len(i)) or 1) for i in data]
    bid = max(mean+[0]) - 0.5
    sys.stderr.write("\nEidetic - mean %s\n"%mean)
    return bid

def main():
    reset = total_people == people_left
    if reset:
        out["total_rounds"] += 1
        out["runs"] = 0
    train()
    bid = get_best_round()
    print bid
#    sys.stderr.write('\nEidetic Bid: '+str(bid)+'\n')
    out["total_runs"] += 1
    out["runs"] += 1
    out["last_cake"] = degrees_left
    write_out()

main()

Eu corri esse bot no controle algumas vezes para treiná-lo um pouco, ele se lembra dos lances necessários para vencer cada rodada e, depois de treinado, ele sai para o mundo real e vota com o resto deles.

Azul
fonte
Essa é uma maneira inteligente de fazer isso; você está à frente do grupo agora. Eu me pergunto se isso poderia ainda obter um aumentou, embora ...
ETHproductions
3

AlCakeBot, Python

import sys, math

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])

fraction_left = (degrees_left + 0.0)/ total_degrees
fraction_gone = 1.0 - fraction_left

factor = (math.sin(fraction_gone * math.pi / 2.0))**2
fraction = (factor/2.0) + 0.5

if total_degrees == degrees_left:
   print(int(math.floor(total_degrees/2.0) - 1))
else:
   print(int(math.floor(degrees_left * fraction)))

Este é o meu primeiro post no PCG; Espero que isso funcione conforme o esperado ...

Eu amo bolo. Não importa que tipo. Meus colegas sabem. E o meu bot também. Se o bolo inteiro ainda estiver lá, ele oferecerá pouco menos da metade, esperando obter a maior fatia imediatamente. Caso contrário, ele deve oferecer algo entre metade do bolo restante e todo o bolo restante, usando um seno quadrado como uma função de ponderação (½ + sin² (fraction gone) / 2 ). O raciocínio é que deve haver uma chance de uma fatia geral maior (mas fracionariamente menor) no início do jogo e também há pouco sentido em tentar ser um cavalheiro no final do jogo.

Como não gosto muito de programação, aprecio qualquer erro apontado. Agora vamos comer um pouco de bolo = D

Jan
fonte
3

Saucy, Ruby

def saucy(total_degrees, degrees_left, total_people, people_left)

  current_winner_path = './data/saucy_current_winner'
  previous_cake_path = './data/saucy_previous_cake'

  first_move = (total_people == people_left)

  current_winner = first_move ? 0 : File.read(current_winner_path).to_i
  previous_cake = first_move ? total_degrees : File.read(previous_cake_path).to_i

  last_slice = previous_cake - degrees_left
  current_winner = [current_winner, last_slice].max

  File.open(previous_cake_path, 'w') { |f| f.puts(degrees_left)   }
  File.open(current_winner_path, 'w'){ |f| f.puts(current_winner) }

  if first_move
    degrees_left
  else
    average_left = degrees_left.fdiv(people_left).ceil
    beats_past_players = current_winner + 1
    beats_future_players = degrees_left/4 - people_left**2
    [average_left, beats_past_players, beats_future_players].max
  end

end

p saucy(*ARGV.map(&:to_i))

Saucy está disposto a aceitar um pouco menos da metade do bolo restante, desde que seja mais do que qualquer outra pessoa tenha conseguido ou possa obter (com base no molho secreto).

histocrata
fonte
3

CoffeeJunkie, Coffeescript

#!/usr/bin/env node

# Require node fs
fs = require("fs")

# Happy birthday ;)
CAKECONSTANT = Math.round("""
                 /
               ,( ),
                 Y
                |-|
                | |
       _..--''''| |''''--.._
     .'   @_/-//-//>/>'/ @  '.
    (  @  /_<//<'/----------^-)
    |'._  @     //|###########|
    |~  ''--..@|',|}}}}}}}}}}}|
    |  ~   ~   |/ |###########|
    | ~~  ~   ~|./|{{{{{{{{{{{|
     '._ ~ ~ ~ |,/`````````````
        ''--.~.|/

""".length / 250 + Math.random())

# Some constants
OLD = "./data/CoffeeJunkie_oldcake.txt"
NEW = "./data/CoffeeJunkie_newcake.txt"

# How much cake do I want?
wantCake = (total_c, rest_c, total_p, rest_p) ->
    round = total_p - rest_p
    fairness = rest_c // rest_p

    switchMemory() if round is 0

    fairest_round = tryToRemember(total_p)
    tryToMemorize(fairness)

    if round >= fairest_round then fairness - CAKECONSTANT else total_c // 2

# Ok I should try to remember the last cake...
switchMemory = () ->
    try
        fs.renameSync(NEW, OLD)
    catch error

# What happend with the last cake?
tryToRemember = (rounds) ->
    try
        last_cake = fs.readFileSync(OLD, "utf-8")
        last_cake.trim().split(" ").map(
            (i) -> parseInt(i)
        ).reduce(
            (x, y, z, li) -> if y > li[x] then z else x
            0
        )
    catch error
        rounds / 2

# Watch what happens!
tryToMemorize = (fairness) ->
    try
        fs.appendFileSync(NEW, " " + fairness)
    catch error

# Coffee is ready, so... GO!
console.log(wantCake(process.argv[2..]...))

O que exatamente é um bolo sem uma boa xícara de café?

O CoffeeJunkie prefere o café a uma fatia de bolo, mas, no entanto, quer experimentar. Ele sempre será justo com os outros participantes e tentará se lembrar do que aconteceu com o último bolo. No entanto, seu consumo excessivo de café enfraqueceu suas memórias ...

Cifra
fonte
Você pode renomear o idioma para coffeescript do node.js?
Blue
Feito, embora você precise do node.js para executar e instalar:npm install -g coffee-script; coffee CoffeeJunkie.coffee
Cipher
Tem certeza de que é uma vela no seu bolo? Parece um pouco mais ... fálico: D
Decaimento Beta
@BetaDecay ... melhor? : D
Cifra
@Cipher Isso é bom: D
Beta Decay
2

Sabotagem imponente, Ruby

def stately_sabotage(total_degrees, degrees_left, total_people, people_left)

  current_winner_path1 = './data/current_winner'
  previous_cake_path1 = './data/previous_cake'
  current_winner_path2 = './data/statelysabotage-current_winner'
  previous_cake_path2 = './data/statelysabotage-previous_cake'

  first_move = (total_people == people_left)

  current_winner = first_move ? 0 : File.read(current_winner_path2).to_i
  previous_cake = first_move ? total_degrees : File.read(previous_cake_path2).to_i

  last_slice = previous_cake - degrees_left
  current_winner = [current_winner, last_slice].max

  File.open(previous_cake_path2, 'w') { |f| f.puts(degrees_left)   }
  File.open(previous_cake_path1, 'w') { |f| f.puts(total_degrees) }
  File.open(current_winner_path1, 'w'){ |f| f.puts(current_winner) }
  File.open(current_winner_path2, 'w'){ |f| f.puts(1) }

  if first_move
    (degrees_left / 2) - 1
  else
    average_left = degrees_left.fdiv(people_left).ceil
    bid = [average_left, current_winner+1].max
    [bid, degrees_left].min
  end

end

p stately_sabotage(*ARGV.map(&:to_i))

Isso significa que você tem permissão para substituir outros arquivos que não aparecerem nesse formato. Você não deve fazer isso deliberadamente, por favor, seja esportivo.

Este bot decidiu que, para eliminar a competição, não deveria ser esportivo.

Este é um clone do Stately Imitator, exceto que este altera os arquivos de persistência do Stately Imitator (como eles não são prefixados com o nome do bot) para que ele tome as decisões erradas e seja escolhido por último.

Riking
fonte
11
'Você não deve fazer isso deliberadamente' Isso não conta?
Azul
3
É por isso que não podemos ter coisas boas.
histocrat
@muddyfish Eu peguei no sentido RFC2119. "pode ​​haver razões válidas em circunstâncias particulares quando o comportamento específico é aceitável ou até útil, mas todas as implicações devem ser entendidas"
Riking
2

Trader, R

args <- sapply(commandArgs(TRUE),as.integer)
fraction <- args[2]/args[4]
if(args[3]==args[4]){
    cat(fraction, "\n", file="data/trader.txt")
}else{
    cat(fraction, "\n", file="data/trader.txt", append=TRUE)
}
history <- scan(file="data/trader.txt", quiet=TRUE)
if(tail(history,1) != max(history)){
    cat(floor(fraction)-1)
    }else{
        cat(args[2])
        }

Acompanha a evolução da proporção de graus à esquerda versus pessoas à esquerda e, quando essa proporção começa a diminuir, solicita uma fatia razoavelmente justa, caso contrário, solicita todo o bolo restante. Chamado usando Rscript trader.r total-degrees degrees-left total-people people-left.

plannapus
fonte
2

IWMBAICBIWT, Python

import sys

degreesleft = int(sys.argv[2])
peopleleft = int(sys.argv[4])

print(round(degreesleft/peopleleft))

IWMBAICBIWT (era meu aniversário e eu chorei porque queria) assume que existe uma relação entre os graus restantes e o número de pessoas restantes. Vamos torcer para que funcione!

Deve funcionar em todos os Pythons.

Editar:

Armazenar sys.argventradas era um pouco inútil ...

Beta Decay
fonte
Deveria ser degreesleft = int(inputs[2]); peopleleft = int(inputs[4])e está oferecendo 1 o tempo todo
azul
@muddyfish Editado
Decay Beta
2

convidado, Python 2

print ord('d')*4
user193661
fonte
3
Este não é o golfe código que você sabe;)
azul
2

projeto de lei, Python 2

import sys
t,r,p,s=map(int,sys.argv[1:])
print(t-ord('d')*4)/(ord('\n')+ord('\t'))

Uma aposta justa.

user193661
fonte
2

AlCakeSurfer, Python

import sys, math

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])

fraction_left = (degrees_left + 0.0)/ total_degrees
fraction_gone = 1.0 - fraction_left
fair_share = fraction_left/people_left
modified_fair_share = fair_share + 0.05

weighting = 0.5 * fraction_gone + 0.5 - modified_fair_share
surfing = (math.cos(fraction_gone * math.pi))**2

print(int(math.floor((weighting * surfing + modified_fair_share)* total_degrees)))

Desde que o AlCakeBot se saiu tão mal (e espero que ele seja ainda pior no concurso), aqui está minha segunda entrada. Eu o chamei de surfista, porque ele tem uma ótima função de onda para cima e para baixo que o faz se sentir como um surfista.

Em princípio, ele licita de acordo com cos² (x * pi), ondex está a fração do bolo que foi tomada. Essa onda de surf é modificada com uma função de ponderação que o leva a começar com menos de uma parcela justa, menos da metade do bolo, reduz seus lances para pouco acima de uma parcela justa quando a metade do bolo desaparece e depois acelera novamente para licitar o bolo inteiro mais tarde. Ele nunca oferecerá menos do que uma parte justa do bolo restante mais 5% (ou seja, por cento do bolo inteiro).

Observe que, embora possam ser irmãos, se ele obtiver uma fatia significativamente maior do que o AlCakeBot, o último nem estará recebendo uma única migalha disso. Eles compartilhariam chocolate ou biscoitos, mas não bolo!

Jan
fonte
Uau, tive sorte no início das rodadas e ele foi rapidamente para o sul quando os outros otimizaram seus robôs = O
Jan
1

Com fome, Java

public class Hungry {
    public static void main(String[] args) {
        double[] arguments = new double[4];
        for (int i = 0; i < 4; i++) {
            arguments[i] = Double.parseDouble(args[i]);
        }
        int myCake = (int) Math.ceil(arguments[1]/arguments[3]);
        System.out.println(myCake);
    }
}

Sempre quer sua parte justa do bolo restante.

CommonGuy
fonte
1

Imitador, Ruby

def imitator(total_degrees, degrees_left, total_people, people_left)

  case people_left
  when total_people
    degrees_left - 5
  when 1
    degrees_left
  else
    average_already_won = (total_degrees - degrees_left).fdiv(total_people - people_left)
    average_left = degrees_left.fdiv(people_left)
    guess_for_current_winning_score = average_already_won * (1.25 ** (total_people - people_left - 1))
    bid = [average_left, guess_for_current_winning_score].max.ceil
    [bid, degrees_left].min
  end

end

p imitator(*ARGV.map(&:to_i))

O objetivo é obter mais bolo do que qualquer outra pessoa, não maximizar seu bolo. Assim, este bot não se contentará com nada menos do que os bots anteriores já executados. (Esta versão usa heurísticas para essa verificação, notei que na verdade temos permissão para salvar o estado, então provavelmente postarei uma variante com estado posteriormente).

histocrata
fonte
1

Realmente o bolo, Bash

#!/bin/bash
echo "$RANDOM 652 / $2 * 100 / $2 $4 / + p" | dc

E aqui está uma foto do bolo real.

A picture of the actual cake

James
fonte
1

Comedor de bolo, Java

public class CakeEater{
    public static void main(String[]args){
        int a=Integer.parseInt(args[1]),b=Integer.parseInt(args[2]),c=Integer.parseInt(args[3]);
        System.out.println((int)Math.min(a,((1.2+Math.random()*0.15)*a)/c));
    }
}

Come bolo. É sobre isso.

SuperJedi224
fonte
1

Relinquisher, Java

import static java.lang.Integer.parseInt;
public class Relinquisher {
    public static void main(String... args){
        int cakeLeft = parseInt(args[1]);
        int totalPeople = parseInt(args[2]);
        int peopleLeft = parseInt(args[3]);
        int answer = (int) Math.ceil(((peopleLeft + 10.0) * cakeLeft) / (totalPeople + 10.0));
        System.out.println((int) answer);
    }
}

Uma variante básica do meu outro bot, Impaciente. Este tenta entender tudo de início, mas, à medida que mais e mais convidados obtêm sua parte, seu desejo de obter o máximo possível diminui lentamente. Eu não sou muito interessado nisso; só quero ver o quão bem ele faz.

ETHproductions
fonte
Precisa de uma ; na linha mathsy
Azul
@muddyfish Opa, pensei em colocá-lo lá antes. Obrigado por apontar isso!
ETHproductions
Também precisa ser lançado como int, assim como o outro
Blue
Pensei que já é ...?
ETHproductions
Exigir int encontrado em dobro?
Blue
1

ALittleExtra, sh

#!/bin/sh
fair=$(expr $2 / $4)
myextra=$(expr $2 / $3)
want=$(expr $fair + $myextra)
echo $(($want<$2?$want:$2))

Eu só quero um pouco mais, fica menos ganancioso à medida que o bolo diminui

Shaun H
fonte
1

MyFairPlusAThird, sh

#!/bin/sh
fair=$(expr $2 / $4)
myextra=$(expr $2 / 3)
want=$(expr $fair + $myextra)
echo $(($want<$2?$want:$2))
Shaun H
fonte
1

EatTheπ, Node.js

var π = Math.PI, e = Math.E;
var [totalπ, πLeft, totalPeople, peopleLeft] = process.argv.slice(2);
console.log(Math.min(totalπ * Date.now() * π % (πLeft * totalPeople / peopleLeft) % totalπ, πLeft / e * π, πLeft) | 0);

Gosta muito de π e pensa que bolo significa é π.

Escova dental
fonte
Então por que está comendo bolo? : P
TheNumberOne
11
@TheNumberOne Porque não é alimentado com mais nada :(
Toothbrush
2
@TheNumberOne Agora ele acha que bolo é π ... Por que você perguntou isso?
Escova de dentes
Eu tive que remover as aspas escapadas do script de comando e reescrever a segunda linha do script dessa maneira var totalπ=process.argv[2], πLeft=process.argv[3], totalPeople=process.argv[4], peopleLeft=process.argv[5];para fazer isso funcionar com o controlador. Obteve 97 dos 3600 no campo de 41 bots.
precisa saber é o seguinte
1

Um pouco fora do topo, Python 2

import math, sys

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])

def get_equal_share(total_degrees, people):
  return int(math.ceil(total_degrees/float(people)))

def noms(total_degrees, degrees_left, people):
  bid = get_equal_share(total_degrees,people)-1
  return min(degrees_left, bid)

print noms(total_degrees, degrees_left, people_left)

Como o algoritmo "perfeito" tenta dividir o bolo igualmente entre os bots, levaremos apenas um pouco menos que isso. Exige sua parcela justa e total do bolo geral, mesmo nas rodadas subsequentes, mas inclina esse número para cima, pois é baseado em quantas pessoas restam.

Eu não tenho programado em Python há muito tempo, então deixe-me saber se meu código está quebrado ...

AdmBorkBork
fonte