É 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 .

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.

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

Slim, Python 2

print 0

Esse bot está de dieta.

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

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.

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)

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.

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 .

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.

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.

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

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.

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

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

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

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.

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.

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

convidado, Python 2

print ord('d')*4

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.

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!

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.

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

Realmente o bolo, Bash

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

E aqui está uma foto do bolo real.

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.

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.

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

MyFairPlusAThird, sh

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

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 é π.

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