È il mio diciassettesimo compleanno e sei invitato alla mia festa!

E come sempre alle feste, ci sarà la torta.

Una torta ...

E ne hai bisogno il più possibile.

Dato che questa è una festa giusta, ognuno di noi dirà quanto della mia torta vogliamo e la persona che ha detto la minima quantità la riceverà. Quindi tutti gli altri possono ripetere il processo fino a quando la torta è scomparsa.

Sfida

• Dato l'input tramite argomenti della riga di comando sotto forma di total-degrees degrees-left total-people people-left, output allo standard output integer-bid-in-degrees.
• Se la tua offerta è stata la più bassa, ricevi quella quantità di torta e sei fuori per il round.
• Se la tua offerta non era più bassa, il tuo bot può fare offerte sulla torta rimanente.
• Nel caso in cui le offerte più basse siano uguali, la persona rimossa verrà scelta a caso.
• Alla fine di un round, una volta che tutta la torta è sparita o non c'è più nessuno a fare offerte su di essa, la persona con più torta vince!
• Nel caso alla fine di un round e due persone abbiano la fetta più grande della stessa dimensione, il vincitore viene scelto a caso tra le voci del disegno.

gameplay

• Ci saranno 17 round, il vincitore assoluto sarà l'ingresso con il maggior numero di vittorie complessive.
• In caso di pareggio, i round verranno giocati fino a quando non ci sarà un chiaro vincitore.
• Ogni giorno aggiornerò i punteggi attuali in modo che le persone possano aggiornare la propria iscrizione.

Presentazione

Dovresti scrivere la tua voce come

Nome bot, lingua

Insert
Code
Here

Spiegazione / Materiale casuale qui

Se la voce non è formattata in questo modo, il controller NON sarà in grado di eseguire la voce. Se scopro che è successo alla tua iscrizione, ti informerò in un commento e / o modificherò la risposta nel formato corretto.

La tua voce e archiviazione dei file

• Il bot può archiviare i file nella ./data/directory e in nessun altro luogo.
  • Non richiesto ma si prega di archiviare i file come botname*
  • Non è possibile scrivere file in questo formato se botnamenon è il nome delle voci.
  • Ciò significa che ti è permesso di sovrascrivere altri file che trovi che non compaiono in questo formato. Non dovresti farlo deliberatamente, per favore, fai sport.
  • Il tuo bot non deve presumere che i file richiesti siano presenti ma può presumere che ./data/esista.
  • Questo perché ogni tanto pulisco la ./datadirectory, lo farò quando iniziano i round. (Ma non tra di loro)
• Il tuo bot potrebbe non eliminare affatto i file
• Al tuo bot è consentito solo leggere file nella ./data/directory
  • Questo significa che puoi guardare altri file di voci

risultati:

Meek ha vinto il concorso! Ben fatto @ Cabbie407

E ora per alcune statistiche casuali:

Un elenco di posizioni in cui è entrato ciascun bot: (Ben fatto a qualsiasi bot che appare in questo elenco, sei arrivato tra i primi 5 almeno una volta!)

1. Mite, Meek, Eidetic, Eidetic, Meek, Eidetic, Eidetic, Meek, Meek, Meek, Muce, Saucy, Meek, Givemethecake, Givemethecake, Givemethecake, Meek, Eidetic

2. Eidetic, Eidetic, Meek, AlCakeSurfer, Eidetic, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, 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, Relf, ​​fattura

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

Il file di registro completo della competizione durante l'esecuzione è disponibile qui . Mi dispiace per il cambio di formato a metà.

Non eseguirò di nuovo il concorso, se vuoi pubblicare più voci, puoi farlo, il controller può essere trovato sul mio repository github per questo concorso .

Mite, awk

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

L'ho visto una volta in una simulazione.

Mago, Java

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

Il numero 720 è magico.

_{Questo è stato lo scopo di verificare il controller ed è non è una voce seria.}

Sottile, Python 2

print 0

Questo robot è a 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;
}

Precedentemente FairBot

FairBot vuole solo una parte uguale :(

Vuole dividere la torta in modo uniforme tra tutti i partecipanti.

(Si aspetta completamente che gli altri robot lo derubino perché sa che sono cattivi)

(Davvero. È solo, vuole solo piacere agli altri robot)

(È appena uscito da una brutta relazione e sta attraversando una patch davvero dura, quindi se tu potessi semplicemente dargli una pacca sulla spalla e un sorriso per farlo sentire meglio significherebbe davvero molto.)

EDIT ha cambiato programma per prendere input da argv / c invece di stdin (fair bot è ancora triste .... Vuole cambiare il suo nome in sadbot (che è un po 'il motivo per cui vuole una torta))

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

Scrupolosamente, inequivocabilmente giusto. Metà della torta per me, metà della torta per tutti gli altri.

CharityBot, Python 2

print -360

Aggiunge un'altra torta al mix!

(Il controller vedrà questa come una richiesta per 0 torta, non aggiungerà effettivamente alla dimensione della torta)

Imitatore signorile, 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 di imitatore (se preferisci solo una voce per giocatore, questa sostituisce quella). Tiene traccia precisa della fetta più grande già presa e offre sempre abbastanza da battere quella fetta. Inoltre, l'offerta non sarà mai inferiore alla sua giusta quota del resto. Presuppone che esiste già una directory './data' di lettura / scrittura; i file possono essere già presenti oppure no.

Dieter, Java

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

Non vuole fare un'offerta per troppa torta, quindi sceglie una fetta casuale piccola ma garantita .

Flaming Chainsaw, 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]);}
    }
}

Hai mai provato a organizzare una gara di taglio con una motosega? Bene, ora hai. È piuttosto dirompente.

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

Aspetta le persone che mangiano una buona dose o meno prima di mangiare qualsiasi torta. Per impedire agli avidi di ottenere una torta in più, ne prende la maggior parte possibile.

Bob Barker, Java

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

Questo probabilmente verrà sostituito con una soluzione più ponderata in seguito, ma sono curioso di sapere se funzionerà. Questo è solo per catturare tutti i robot che cercano di ottenere il massimo, e fare una strategia Price is Right modificata per rubare la loro risposta. Potrebbe portare a un'escalation con l'aumentare delle sottrazioni di numeri interi, sarebbe perfetto.

EDIT: inizia l'escalation, contro-invio contro FloorBot

Eidetic, 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()

Ho eseguito questo robot nel controller un paio di volte per allenarlo un po ', ricorda le offerte richieste per vincere ogni round e poi, una volta allenato, esce nel mondo reale e vota con il resto di loro.

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

Questo è il mio primo post su PCG; Spero che funzioni come previsto ...

Adoro la torta. Non importa quale tipo. I miei colleghi lo sanno. E anche il mio bot. Se l'intera torta è ancora lì, farà un'offerta per poco meno della metà, sperando di ottenere immediatamente la fetta più grande. In caso contrario, dovrebbe offrire qualcosa tra metà della torta rimanente e tutta la torta rimanente, utilizzando un seno quadrato come funzione di ponderazione (½ + sin² (fraction gone) / 2 ). Il ragionamento è che ci dovrebbe essere la possibilità di una fetta complessivamente più grande (ma frazionalmente più piccola) all'inizio del gioco e che ci sia anche poco senso nel cercare di essere un gentiluomo alla fine del gioco.

Dal momento che non mi interessa molto la programmazione, apprezzerò qualsiasi errore sottolineato. Ora mangiamo un po 'di torta = D

Impertinente, rubino

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 è disposto ad accettare un po 'meno della metà della torta rimanente, purché sia ​​più di quanto chiunque altro abbia ottenuto o sia probabile che ottenga (sulla base di salsa segreta).

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

Cos'è esattamente una torta senza una buona tazza di caffè?

CoffeeJunkie preferisce il caffè a una fetta di torta, ma vuole comunque provarne un po '. Sarà sempre giusto con gli altri partecipanti e cercherà di ricordare cosa è successo all'ultima torta. Tuttavia, il suo eccessivo consumo di caffè ha indebolito i suoi ricordi ...

Sabotaggio signorile, 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))

Ciò significa che ti è permesso di sovrascrivere altri file che trovi che non compaiono in questo formato. Non dovresti farlo deliberatamente, per favore, fai sport.

Questo bot ha deciso che, al fine di eliminare la concorrenza, non dovrebbe essere sportivo.

Questo è un clone di Stately Imitator, tranne per il fatto che questo incasina i file di persistenza di Stately Imitator (poiché non hanno il prefisso con il nome del bot) in modo che prenda le decisioni sbagliate e venga scelto per ultimo.

Commerciante, 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])
        }

Tiene traccia dell'evoluzione dei gradi a sinistra rispetto al rapporto a sinistra delle persone e quando quel rapporto inizia a diminuire, chiede una porzione ragionevolmente equa, altrimenti chiede l'intera torta rimanente. Richiamato 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 il mio compleanno e ho pianto perché volevo) presume che ci sia una relazione tra i gradi rimasti e il numero di persone rimaste. Speriamo che funzioni!

Dovrebbe funzionare in tutti i Python.

Modificare:

La memorizzazione sys.argvnegli input è stata un po 'dispendiosa ...

ospite, Python 2

print ord('d')*4

fattura, Python 2

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

Una scommessa equa.

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

Dato che AlCakeBot ha fatto così male (e mi aspetto che faccia ancora peggio nel concorso) ecco la mia seconda voce. L'ho chiamato Surfer, perché ha una funzione d'onda su e giù molto bella che lo fa sentire un surfista.

In linea di principio, fa un'offerta secondo cos² (x * pi), dovex la frazione della torta che è stata presa. Questa onda di surf viene modificata con una funzione di ponderazione che gli fa iniziare a meno di una buona parte meno della metà della torta, riduce le sue offerte a poco sopra una buona parte quando la metà è scomparsa, e quindi accelera di nuovo a fare offerte per l'intera torta in seguito. Non offrirà mai meno di una buona parte della torta rimanente più il 5% (percentuale dell'intera torta, cioè).

Nota che sebbene possano essere fratelli, se ottiene una fetta significativamente più grande di AlCakeBot, quest'ultimo non ne ottiene nemmeno una briciola. Condividono il cioccolato o i biscotti, ma non la torta!

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

Vuole sempre la sua giusta quota della torta rimanente.

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

L'obiettivo è ottenere più torte di chiunque altro, non massimizzare la tua torta. Pertanto, questo bot non si accontenterà di meno di quello che i bot precedenti hanno già preso. (Questa versione utilizza l'euristica per quel controllo, ho appena notato che in realtà è consentito salvare lo stato, quindi probabilmente posterò una variante con stato in seguito).

Davvero la torta, Bash

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

Ed ecco una foto della vera torta.

Mangiatore di torta, 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));
    }
}

Mangia la torta. Questo è tutto.

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

Una variante di base dell'altro mio robot, Impaziente. Questo cerca di prendere tutto all'inizio, ma man mano che sempre più ospiti ottengono la loro parte, il suo desiderio di ottenere il più lentamente possibile diminuisce. Non sono troppo preso da questo; voglio solo vedere quanto va bene.

ALittleExtra, sh

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

Voglio solo un po 'di più, diventa meno goloso man mano che la torta diminuisce

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

Really likes π, and thinks that cake means is π.

A Little Off The Top, 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)

Since the "perfect" algorithm tries to split the cake evenly between the bots, we're going to take just a sliver less than that. Demands its full fair share of the overall cake, even in subsequent rounds, but skews that number upward since it's based on how many people are left.

_{I haven't programmed in Python in a long while, so let me know if my code is broken...}