¡Es mi 17 cumpleaños y estás invitado a mi fiesta!

Y como siempre en las fiestas, habrá pastel.

Un pastel ...

Y necesitas tanto como sea posible.

Como esta es una fiesta justa, cada uno de nosotros dirá cuánto de mi pastel queremos y la persona que dijo la cantidad más pequeña lo conseguirá. Luego, todos los demás pueden repetir el proceso hasta que se acabe el pastel.

Reto

• Dada la entrada a través de argumentos de línea de comando en forma de total-degrees degrees-left total-people people-left, salida a salida estándar integer-bid-in-degrees.
• Si su oferta fue la más baja, recibirá esa cantidad de pastel y estará fuera para la ronda.
• Si su oferta no fue la más baja, su bot podrá ofertar por el pastel restante.
• En el caso de que las ofertas más bajas sean las mismas, la persona eliminada será elegida al azar.
• Al final de una ronda, una vez que todo el pastel se ha ido o no queda nadie para pujar, ¡la persona con más pastel gana!
• En el caso al final de una ronda y dos personas tienen la porción más grande del mismo tamaño, el ganador se elige al azar de las entradas del sorteo.

Jugabilidad

• Habrá 17 rondas, el ganador general será la entrada con más victorias en general.
• En caso de empate, se jugarán rondas hasta que haya un claro ganador.
• Cada día, actualizaré los puntajes actuales para que las personas puedan actualizar su entrada.

Sumisión

Deberías escribir tu entrada como

Nombre del bot, idioma

Insert
Code
Here

Explicación / cosas al azar aquí

Si su entrada no está formateada de esta manera, el controlador NO podrá ejecutar su entrada. Si descubro que esto le sucedió a su entrada, se lo notificaré en un comentario y / o editaré la respuesta en el formato correcto.

Su entrada y almacenamiento de archivos

• Su bot puede almacenar archivos en el ./data/directorio y en ningún otro lugar.
  • No es necesario, pero guarde sus archivos como botname*
  • No puede escribir archivos en este formato si botnameno es el nombre de su entrada.
  • Esto significa que puede sobrescribir otros archivos que encuentre que no aparecen en este formato. No deberías hacer esto deliberadamente, por favor, diviértete.
  • Su bot no debe asumir que los archivos que requiere están presentes, pero puede suponer que ./data/existen.
  • Esto se debe a que ocasionalmente borro el ./datadirectorio, lo haré cuando comiencen las rondas. (Pero no entre ellos)
• Es posible que su bot no elimine archivos en absoluto
• Su bot solo puede leer archivos en el ./data/directorio
  • Esto significa que puede mirar otros archivos de entradas

Resultados:

¡Meek ganó el concurso! Bien hecho @ Cabbie407

Y ahora para algunas estadísticas aleatorias:

Una lista de las posiciones en las que entró cada bot: (¡Bien hecho a cualquier bot que aparezca en esta lista, llegaste al top 5 al menos una vez!)

1. Meek, Meek, Eidetic, Eidetic, Meek, Eidetic, Eidetic, Meek, Meek, Meek, 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, Relin, mi

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

El archivo completo de registro de la cometa mientras se ejecuta se puede encontrar aquí . Perdón por el cambio de formato a la mitad.

No volveré a ejecutar el concurso, si desea publicar más entradas, puede hacerlo, el controlador se puede encontrar en mi repositorio de github para este concurso .

Meek, awk

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

Vi esto una vez en una simulación.

Mago, Java

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

El número 720 es mágico.

_{Esto se estaba destinado a probar el controlador y es no una entrada grave.}

Slim, Python 2

print 0

Este bot está 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;
}

Anteriormente FairBot

FairBot solo quiere una porción igual :(

Quiere dividir el pastel de manera uniforme entre todos los participantes.

(Sin embargo, espera que los otros bots lo saqueen porque sabe que son malos)

(Como realmente. Está solo, solo quiere que a los otros robots les guste)

(Acaba de salir de una mala relación y está pasando por un mal momento, así que si pudieras darle una palmadita en la espalda y una sonrisa para que se sienta mejor, realmente significaría mucho).

EDITAR cambió el programa para recibir información de argv / c en lugar de stdin (el bot justo todavía está triste ... Él quiere cambiar su nombre a sadbot (que es por eso que quiere pastel))

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, impecablemente justo. La mitad del pastel para mí, la mitad del pastel para todos los demás.

CharityBot, Python 2

print -360

¡Agrega otro pastel a la mezcla!

(El controlador verá esto como una solicitud de pastel 0, en realidad no se agregará al tamaño del pastel)

Imitador señorial, rubí

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 de Imitator (si prefiere solo una entrada por jugador, esta reemplaza a esa). Mantiene un seguimiento preciso de la porción más grande ya tomada, y siempre ofrece lo suficiente como para superar esa porción. Tampoco ofertará más bajo que su parte equitativa del resto. Asume que ya existe un directorio './data' de lectura / escritura; los archivos pueden estar allí o no.

Dieter, Java

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

No quiere apostar por demasiado pastel, por lo que elige una porción aleatoria pequeña pero garantizada .

Motosierra llameante, 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]);}
    }
}

¿Alguna vez has intentado organizar un concurso de cortar pasteles con una motosierra? Bueno, ahora lo tienes. Es bastante disruptivo.

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

Espera a las personas que comen una porción justa o menos antes de comer cualquier pastel. Para evitar que el codicioso obtenga pastel extra, toma la porción más grande posible.

Bob Barker, Java

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

Probablemente, esto será reemplazado con una solución más pensada más adelante, pero tengo curiosidad por saber si esto funcionará. Esto es solo para atrapar a cualquier bot que intente obtener el máximo, y hacer una estrategia modificada de Price is Right para robar su respuesta. Podría conducir a una escalada con sustracciones de números enteros cada vez mayores, eso sería genial.

EDITAR: comienza la escalada, contra-publicación contra 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()

Ejecuté este bot en el controlador un par de veces para entrenarlo un poco, recuerda las ofertas requeridas para ganar cada ronda y luego, una vez entrenado, sale al mundo real y vota con el resto de ellos.

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

Esta es mi primera publicación PCG; Espero que esto funcione según lo previsto ...

Me encanta el pastel. No importa de qué tipo. Mis colegas lo saben. Y también mi bot. Si toda la torta todavía está allí, ofertará por menos de la mitad, con la esperanza de obtener la porción más grande de inmediato. De lo contrario, debe ofertar por algo entre la mitad del pastel restante y todo el pastel restante, utilizando un seno cuadrado como función de ponderación (½ + sin² (fraction gone) / 2 ). El razonamiento es que debería haber una posibilidad de una porción general más grande (pero fraccionalmente más pequeña) al principio del juego y también tiene poco sentido tratar de ser un caballero al final del juego.

Como no estoy muy interesado en la programación, agradeceré cualquier error señalado. Ahora comamos pastel = 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á dispuesta a aceptar un poco menos de la mitad del pastel restante, siempre que sea más de lo que cualquier otra persona haya recibido o pueda obtener (según la salsa secreta).

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

¿Qué es exactamente un pastel sin una buena taza de café?

El CoffeeJunkie prefiere el café en lugar de una rebanada de pastel, pero sin embargo quiere probar un poco. Siempre será justo con los demás participantes e intentará recordar lo que sucedió con el último pastel. Sin embargo, su consumo excesivo de café ha debilitado sus recuerdos ...

Sabotaje señorial, rubí

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

Esto significa que puede sobrescribir otros archivos que encuentre que no aparecen en este formato. No deberías hacer esto deliberadamente, por favor, diviértete.

Este bot decidió que para eliminar la competencia, no debería ser deportivo.

Este es un clon de Stately Imitator, excepto que este desordena los archivos de persistencia de Stately Imitator (ya que no tienen el prefijo con el nombre del bot) para que tome las decisiones equivocadas y se elija al final.

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

Realiza un seguimiento de la evolución de la proporción de grados restantes frente a personas y, cuando esa proporción comienza a disminuir, solicita una porción razonablemente justa, de lo contrario, solicita el pastel restante. Invocado 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 mi cumpleaños y lloré porque quería) supone que existe una relación entre los grados restantes y la cantidad de personas que quedan. ¡Esperemos que funcione!

Debería funcionar en todas las pitones.

Editar:

Almacenar sys.argventradas fue un poco despilfarrador ...

invitado, Python 2

print ord('d')*4

proyecto de ley, Python 2

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

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

Como AlCakeBot lo hizo tan mal (y espero que lo haga aún peor en el concurso) aquí está mi segunda entrada. yo lo llamé Surfer, porque tiene una función de onda ascendente y descendente muy agradable que lo hace sentir como un surfista.

En principio, él puja según cos² (x * pi) dónde xestá la fracción de pastel que se ha tomado. Esta ola de surf se modifica con una función de ponderación que hace que comience con menos de la mitad del pastel, reduce sus ofertas a poco más de una parte justa cuando la mitad del pastel desaparece y luego vuelve a acelerar. a pujar por el pastel entero más tarde. Nunca ofertará menos que una parte justa del pastel restante más el 5% (es decir, el porcentaje del pastel completo).

Tenga en cuenta que si bien pueden ser hermanos, si obtiene una porción significativamente más grande que AlCakeBot, este último ni siquiera obtiene una migaja de eso. ¡Compartirían chocolate o galletas, pero no pastel!

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

Siempre quiere su parte justa del pastel restante.

Imitador, rubí

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

El objetivo es obtener más pastel que nadie, no maximizar su pastel. Por lo tanto, este bot no se conformará con menos de lo que los bots anteriores ya han tomado. (Esta versión usa heurística para esa verificación, acabo de notar que en realidad se nos permite guardar el estado, por lo que probablemente publicaré una variante con estado más adelante).

Realmente el pastel, Bash

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

Y aquí hay una foto del pastel real.

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

Se come pastel. Eso es todo.

Renunciante, 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 básica de mi otro bot, Impaciente. Este intenta tomar todo al principio, pero a medida que más y más invitados obtienen su parte, su deseo de obtener el máximo posible disminuye lentamente. No estoy demasiado metido en este; Solo quiero ver qué tan bien lo hace.

ALittleExtra, sh

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

Solo quiero un poco más, se vuelve menos codicioso a medida que el pastel disminuye

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

Realmente le gusta π, y piensa que el pastel medio es π.

Un poco fuera de la cima, 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)

Dado que el algoritmo "perfecto" intenta dividir el pastel de manera uniforme entre los bots, vamos a tomar un poco menos que eso. Exige su parte justa total del pastel general, incluso en rondas posteriores, pero sesga ese número hacia arriba ya que se basa en la cantidad de personas que quedan.

_{No he programado en Python en mucho tiempo, así que avíseme si mi código está roto ...}