To moje 17 urodziny i jesteś zaproszony na moje przyjęcie!

I jak zawsze na przyjęciach będzie ciasto.

Jedno ciasto ...

Potrzebujesz jej jak najwięcej.

Ponieważ jest to uczciwa impreza, każdy z nas powie, ile chce mojego ciasta, i osoba, która powiedziała, że ​​najmniejszą ilość, dostanie. Następnie wszyscy inni będą powtarzać proces, aż ciasto zniknie.

Wyzwanie

• Biorąc pod uwagę wejście za pomocą argumentów wiersza poleceń w postaci total-degrees degrees-left total-people people-left, wyjście na standardowe wyjście integer-bid-in-degrees.
• Jeśli twoja oferta była najniższa, otrzymasz taką ilość ciasta i jesteś poza rundą.
• Jeśli Twoja oferta nie była najniższa, Twój bot może licytować pozostałe ciasto.
• W przypadku, gdy najniższe oferty są takie same, osoba usunięta zostanie wybrana losowo.
• Pod koniec rundy, gdy wszystkie ciasto zniknie lub nie będzie już nikogo, kto mógłby licytować, wygrywa osoba z największą ilością ciast!
• W przypadku, gdy na końcu rundy dwie osoby mają największy plasterek o tej samej wielkości, zwycięzca jest wybierany losowo z wpisów losowania.

Rozgrywka

• Odbędzie się 17 rund, a zwycięzcą zostanie zwycięzca z największą liczbą wygranych.
• W przypadku remisu rundy będą rozgrywane do momentu wyłonienia wyraźnego zwycięzcy.
• Każdego dnia będę aktualizować bieżące wyniki, aby ludzie mogli ulepszyć swój wpis.

Uległość

Powinieneś napisać swój wpis jako

Nazwa bota, język

Insert
Code
Here

Wyjaśnienie / Losowe rzeczy tutaj

Jeśli twój wpis nie jest sformatowany w ten sposób, kontroler NIE będzie mógł go uruchomić. Jeśli stwierdzę, że tak się stało z twoim wpisem, powiadomię cię w komentarzu i / lub edytuję odpowiedź w odpowiednim formacie.

Twój wpis i przechowywanie plików

• Twój bot może przechowywać pliki w ./data/katalogu i nigdzie indziej.
  • Nie wymagane, ale przechowuj pliki jako botname*
  • Nie możesz zapisywać plików w tym formacie, jeśli botnamenie jest to nazwa twojego wpisu.
  • Oznacza to, że możesz zastąpić inne znalezione pliki, które nie pojawiają się w tym formacie. Nie powinieneś robić tego celowo, proszę, bądź sportowy.
  • Twój bot nie może zakładać, że wymagane pliki są obecne, ale może założyć ./data/, że istnieje.
  • To dlatego, że od czasu do czasu przetrzeć ./datakatalogu, to będzie to zrobić, gdy rund zacząć. (Ale nie między nimi)
• Twój bot może w ogóle nie usuwać plików
• Twój bot może tylko czytać pliki w ./data/katalogu
  • Oznacza to, że możesz przeglądać inne pliki wpisów

Wyniki:

Meek wygrał konkurs! Dobra robota @ Cabbie407

A teraz kilka losowych statystyk:

Lista pozycji, w których pojawił się każdy bot: (Dobra robota dla każdego bota pojawiającego się na tej liście, przynajmniej raz znalazłeś się w pierwszej piątce!)

1. Cichy, Cichy, Eidetyczny, Eidetyczny, Cichy, Eidetyczny, Eidetyczny, Cichy, Cichy, Cichy, Pyskaty, Cichy, 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, Myślisz

5. rachunek, MyFairPlusAThird, rachunek, rachunek, rachunek, rachunek, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, rachunek, Reallythecake, rachunek, ALittleOffTheTop, ALittleOffTheTop, rachunek, rachunek

Pełny plik dziennika komety podczas działania można znaleźć tutaj . Przepraszamy za zmianę formatu w trakcie.

Nie będę ponownie organizować konkursu, jeśli chcesz opublikować więcej wpisów, możesz to zrobić, kontroler można znaleźć na moim repozytorium github dla tego konkursu .

Cicho, awk

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

Widziałem to raz w symulacji.

Magik, Java

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

Liczba 720 jest magiczna.

_{To jest miał przetestować kontroler i jest nie poważna pozycja.}

Slim, Python 2

print 0

Ten bot jest na diecie.

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

Dawniej FairBot

FairBot chce tylko równej części :(

Chce równomiernie podzielić ciasto między wszystkich uczestników.

(W pełni oczekuje, że inne boty go zdzierają, ponieważ wie, że są wredne)

(Naprawdę. Jest samotny, chce tylko, żeby inne boty go polubiły)

(Właśnie wyszedł ze złego związku i przechodzi naprawdę trudną sytuację, więc jeśli mógłbyś po prostu poklepać go po plecach i uśmiechnąć się, aby poczuł się lepiej, to naprawdę wiele by znaczyło).

EDIT zmienił program, aby pobierał dane z argv / c zamiast stdin (uczciwy bot wciąż jest smutny ... Chce zmienić nazwę na sadbot (dlatego trochę chce ciasta))

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

Skrupulatnie, nienagannie uczciwy. Połowa ciasta dla mnie, połowa ciasta dla wszystkich innych.

CharityBot, Python 2

print -360

Dodaje kolejne ciasto do miksu!

(Kontroler zobaczy to jako prośbę o 0 ciastek, tak naprawdę nie zwiększy rozmiaru ciasta)

Okazały naśladowca, 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))

Wariant naśladowcy (jeśli wolisz tylko jeden wpis na gracza, to zastępuje ten). Utrzymuje dokładny ślad największego już wykonanego wycinka i zawsze licytuje wystarczająco dużo, aby pokonać ten wycinek. Nigdy też nie będzie licytować niżej niż jego uczciwa część pozostałych. Zakłada, że ​​katalog „./data” do odczytu / zapisu już istnieje; pliki mogą już tam być lub nie.

Dieter, Java

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

Nie chce licytować za dużo ciasta, więc wybiera mały, ale gwarantowany losowy plasterek.

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

Czy kiedykolwiek próbowałeś zorganizować konkurs cięcia ciasta piłą łańcuchową? Cóż, teraz masz. To raczej destrukcyjne.

Dżentelmen, 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;
    }
}

Czeka na ludzi, którzy jedzą uczciwie lub mniej, zanim zje jakiekolwiek ciasto. Aby zapobiec chciwemu zdobyciu dodatkowego ciasta, bierze tak dużą porcję, jak to możliwe.

Bob Barker, Java

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

Prawdopodobnie zostanie to później zastąpione bardziej przemyślanym rozwiązaniem, ale jestem ciekawy, czy to zadziała. Ma to na celu złapanie botów, które starają się osiągnąć maksimum i wykonać zmodyfikowaną strategię Price is Right, aby ukraść ich odpowiedź. Może to prowadzić do eskalacji wraz ze wzrostem odejmowania liczb całkowitych, co byłoby fajne.

EDYCJA: Rozpoczęcie eskalacji, kontr-posting przeciwko 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()

Uruchomiłem tego bota w kontrolerze kilka razy, aby go trochę wytrenować, pamięta oferty wymagane do wygrania każdej rundy, a następnie po szkoleniu wychodzi do prawdziwego świata i głosuje z resztą.

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

To mój pierwszy post na PCG; Mam nadzieję, że zadziała to zgodnie z przeznaczeniem…

Kocham ciasto. Nie ważne jaki rodzaj. Moi koledzy wiedzą. Podobnie mój bot. Jeśli całe ciasto nadal tam będzie, będzie licytować za prawie połowę, mając nadzieję, że natychmiast zdobędzie największy kawałek. Jeśli nie, powinien licytować o połowę między pozostałym ciastem a pozostałym ciastem, używając sinusoidy jako funkcji ważenia ( ½ + sin² (fraction gone) / 2). Powodem jest to, że na początku gry powinna istnieć szansa na większy (ale ułamkowo mniejszy) kawałek i nie ma sensu starać się być dżentelmenem w późnej fazie gry.

Ponieważ nie interesuję się programowaniem, docenię każdy wskazany błąd. Teraz zjemy trochę ciasta = 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 jest gotów przyjąć nieco mniej niż połowę pozostałego ciasta, o ile jest to więcej niż ktokolwiek inny dostał lub prawdopodobnie dostanie (na podstawie tajnego sosu).

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

Czym dokładnie jest ciasto bez dobrej filiżanki kawy?

CoffeeJunkie woli kawę niż kawałek ciasta, ale mimo to chce spróbować. Zawsze będzie uczciwy wobec innych uczestników i spróbuje przypomnieć sobie, co stało się z ostatnim ciastem. Jednak nadmierne spożywanie kawy osłabiło jego wspomnienia ...

Okazały Sabotaż, 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))

Oznacza to, że możesz zastąpić inne znalezione pliki, które nie pojawiają się w tym formacie. Nie powinieneś robić tego celowo, proszę, bądź sportowy.

Ten bot zdecydował, że aby wyeliminować rywalizację, nie powinno być sportu.

Jest to klon programu Stately Imitator, z tym wyjątkiem, że ten pomieszał pliki uporczywości Stately Imitator (ponieważ nie są one poprzedzone nazwą bota), aby podejmował złe decyzje i był wybierany jako ostatni.

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

Śledzi ewolucję pozostawionych stopni w stosunku do liczby pozostawionych osób, a gdy stosunek ten zaczyna się obniżać, prosi o dość uczciwy kawałek, w przeciwnym razie prosi o całe pozostałe ciasto. Wywołano przy użyciu 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 (To były moje urodziny i płakałem, bo chciałem) zakłada, że ​​istnieje związek między pozostałymi stopniami naukowymi a liczbą pozostałych osób. Miejmy nadzieję, że to zadziała!

Powinien działać we wszystkich pytonach.

Edytować:

Przechowywanie sys.argvdanych wejściowych było trochę marnotrawstwem ...

gość, Python 2

print ord('d')*4

rachunek, Python 2

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

Fairy bet.

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

Ponieważ AlCakeBot zrobił to źle (i spodziewam się, że będzie gorzej w zawodach), oto mój drugi wpis. Nazwałem go Surfer, ponieważ ma on bardzo przyjemną funkcję falowania w górę i w dół, która sprawia, że ​​czuje się jak surfer.

Zasadniczo licytuje według cos² (x * pi), gdzie xjest ułamek ujętego ciasta. Ta fala surfingu jest modyfikowana za pomocą funkcji ważenia, która powoduje, że zaczyna od mniej niż sprawiedliwego udziału mniej niż połowy ciasta, zmniejsza swoje oferty do nieco powyżej uczciwego udziału około, gdy połowa ciasta zniknie, a następnie przyspiesza z powrotem do licytacji całego ciasta później. Nigdy nie będzie licytował mniej niż sprawiedliwego udziału w pozostałym cieście plus 5% (czyli procent całego ciasta).

Zauważ, że chociaż mogą być braćmi, jeśli dostanie znacznie większy kawałek niż AlCakeBot, ten drugi nawet nie dostanie okruchów. Dzielą się czekoladą lub ciastkami, ale nie ciastem!

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

Zawsze chce mieć sprawiedliwy udział w pozostałym cieście.

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

Celem jest zdobycie więcej ciasta niż ktokolwiek inny, a nie maksymalizacja tortu. Tak więc ten bot nie zadowoli się niczym innym, niż poprzednimi botami. (Ta wersja używa heurystyki do tego sprawdzania, właśnie zauważyłem, że faktycznie możemy zapisać stan, więc prawdopodobnie opublikuję później stanowy wariant).

Naprawdę ciasto, Bash

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

A oto zdjęcie prawdziwego ciasta.

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

Zjada ciasto. O to chodzi.

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

Podstawowy wariant mojego drugiego bota, Niecierpliwy. Ten na początku stara się wziąć całość, ale w miarę jak coraz więcej gości otrzymuje swój udział, jego pragnienie, aby uzyskać jak najwięcej, powoli maleje. Nie przepadam za tym; chcę tylko zobaczyć, jak dobrze sobie radzi.

ALittleExtra, sh

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

Chcę tylko trochę więcej, staje się mniej chciwy, gdy ciasto się kurczy

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

Naprawdę lubi π i myśli, że to ciasto znaczy jest π.

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)

Ponieważ „idealny” algorytm stara się równomiernie rozdzielić ciasto między botami, weźmiemy tylko kawałek mniej. Domaga się pełnego, sprawiedliwego udziału w całym cieście, nawet w kolejnych rundach, ale przekrzywiają tę liczbę w górę, ponieważ zależy to od liczby osób, które pozostały.

_{Dawno nie programowałem w Pythonie , więc daj mi znać, jeśli mój kod jest uszkodzony ...}