Це мій 17-й день народження, і ви запрошені на мою вечірку!

І як завжди на вечірках, буде торт.

Один торт ...

І вам потрібно якнайбільше.

Оскільки це чесна вечірка, кожен з нас скаже, скільки ми хочемо торта, і людина, яка сказала найменшу суму, отримає його. Потім всі інші отримують повторити процес, поки торт не зникне.

Виклик

• Дано введення через аргументи командного рядка у вигляді total-degrees degrees-left total-people people-left, вивести на стандартний вихід integer-bid-in-degrees.
• Якщо ваша ставка була найнижчою, ви отримуєте цю кількість торта і виходите на раунд.
• Якщо ваша ставка була не найнижчою, ваш бот отримує ставки на торт, що залишився.
• У випадку, якщо найнижчі ставки однакові, особу, яку вилучили, вибирають навмання.
• В кінці раунду, як тільки весь торт пропаде або не залишиться нікого, хто подає торги, людина з найбільшою кількістю торта виграє!
• У випадку, якщо в кінці раунду і двоє людей мають однаковий розмір найбільшого шматочка, переможець вибирається навмання із записів жеребкування.

Ігровий процес

• Пройде 17 турів, загальним переможцем стане запис із найбільшою кількістю перемог в цілому.
• У разі нічиєї, раунди будуть розіграні, поки не з’явиться явний переможець.
• Щодня я оновлюватиму поточні бали, щоб люди могли оновити свій запис.

Подання

Ви повинні написати свій запис як

Назва бота, мова

Insert
Code
Here

Пояснення / Випадкові речі тут

Якщо ваш запис не відформатований таким чином, контролер НЕ зможе запустити ваш запис. Якщо я виявлю, що це сталося з вашим записом, я або сповіщу вас у коментарі та / або відредагую відповідь у правильному форматі.

Ваш запис та зберігання файлів

• Ваш бот може зберігати файли в ./data/каталозі і ніде більше.
  • Не потрібно, але зберігайте свої файли як botname*
  • Ви не можете писати файли у такому форматі, якщо botnameце не ваше ім’я.
  • Це означає, що ви можете перезаписати інші файли, які ви знайдете, які не відображаються у такому форматі. Не слід робити це навмисно, будь ласка, займайтеся спортом.
  • Ваш бот не повинен вважати, що потрібні файли є, але він може вважати, що вони ./data/існують.
  • Це тому , що я час від часу протирати ./dataкаталог, я буду робити це , коли обходив на насправді почати. (Але не між ними)
• Ваш бот може взагалі не видаляти файли
• Ваш бот може читати лише файли в ./data/каталозі
  • Це означає, що ви можете переглянути інші файли записів

Результати:

Meek виграв конкурс! Молодці @ Cabbie407

А тепер для декількох випадкових статистичних даних:

Список позицій, до яких прийшов кожен бот: (Добре зробив будь-який бот, який фігурує в цьому списку, ви хоч раз потрапили в топ-5!)

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

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

4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, що відмовляється від права, що відмовляється від права, рахунок, рахунок, який відмовляється від права, MyFairPlusAThird

5. законопроект, MyFairPlusAThird, законопроект, законопроект, законопроект, законопроект, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, законопроект, Reallythecake, законопроект, ALittleOffTheTop, ALittleOffTheTop, законопроект, законопроект

Повний файл журналу комедії під час запуску можна знайти тут . Вибачте за зміну формату частково.

Я більше не буду проводити конкурс, якщо ви хочете опублікувати більше публікацій, ви можете зробити це, контролер можна знайти на моїй репозиторії github для цього конкурсу .

Лагідний, страшний

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

Я бачив це один раз у симуляції.

Маг, Ява

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

Число 720 магічне.

_{Це буде призначалися для тестування контролера і НЕ серйозна запис.}

Slim, Python 2

print 0

Цей бот на дієті.

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

Раніше FairBot

FairBot просто хоче рівну порцію :(

Він хоче розподілити торт рівномірно серед усіх учасників.

(Він повністю розраховує, що інші боти зірвуть його, хоча тому, що він знає, що вони підлі)

(Як насправді. Він самотній, він просто хоче, щоб інші боти подобалися йому)

(Він щойно вийшов з поганих стосунків і переживає дійсно грубу латку, тож, якщо ви могли б просто дати йому погладити по спині та посміхнутись, щоб почувати себе краще, це дійсно означало б багато.)

EDIT змінив програму, щоб взяти вклад з argv / c замість stdin (справедливий бот все ще сумний .... Він хоче змінити своє ім'я на sadbot (це якось чому він хоче торт))

Халвер, Рубі

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

Скрупульозно, безперечно справедливо. Половина торта для мене, половина пирога для всіх інших.

CharityBot, Python 2

print -360

Додає ще один торт до суміші!

(Контролер побачить це як запит на 0 торт, фактично не додасть розмір торта)

Непохитно імітатор, Рубі

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

Варіант програми " Імітатор" (якщо ви хочете мати лише один запис на гравця, це замінює цей). Зберігає точну доріжку найбільшого вже зробленого фрагмента, і завжди вистачає ставок, щоб перемогти цей фрагмент. Також ніколи не буде виставляти ставки нижче своєї справедливої ​​частки, що залишилася. Припускає, що каталог "./data" для читання / запису вже існує; файли можуть бути там уже чи ні.

Дітер, Ява

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

Він не хоче робити торги за занадто багато торта, тому вибирає невеликий, але гарантований випадковий шматочок.

Палаюча бензопила, 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]);}
    }
}

Ви ніколи не пробували провести конкурс на різання торта бензопилою? Ну, тепер у вас є. Це досить руйнівно.

Джентльмен, Ява

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

Він чекає на людей, які їдять справедливу частку або менше, перш ніж з'їсти будь-який торт. Щоб жадібний не отримав зайвий торт, він бере якомога більшу порцію.

Боб Баркер, Java

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

Це, мабуть, пізніше буде замінено більш продуманим рішенням, але мені цікаво, чи це спрацює. Це лише для того, щоб зловити будь-яких ботів, які намагаються досягти максимуму, і зробити модифіковану стратегію Price is Right, щоб вкрасти їх відповідь. Це може призвести до ескалації із збільшенням цілих віднімань, що було б акуратно.

EDIT: Ескалація розпочинається, зустрічне опублікування проти 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()

Я кілька разів запускав цього бота в контролер, щоб трохи його навчити, він запам'ятовує ставки, необхідні для перемоги в кожному раунді, а потім, коли тренується, він виходить у реальний світ і голосує з рештою.

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

Це мій перший пост PCG; Я сподіваюся, що це виходить за призначенням ...

Я люблю торт. Неважливо, який вид. Мої колеги знають. Так само і мій бот. Якщо весь торт все ще є, він подасть заявку на трохи менше половини, сподіваючись отримати найбільший шматочок негайно. Якщо ні, то він повинен подати заявку на щось середнє від половини пирога, що залишився і всього, що залишився, використовуючи квадратний синус як функцію зважування (½ + sin² (fraction gone) / 2 ). Обґрунтовуючи це тим, що на початку гри має бути шанс на загальний більший (але частково менший) відрізок, а також намагатися бути джентльменом у пізній грі є мало сенсу.

Оскільки я не дуже займаюся програмуванням, буду вдячний за будь-яку вказану помилку. Тепер поїмо торт = D

Соус, Рубі

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

Соус готовий прийняти трохи менше половини пирога, що залишився, до тих пір, поки його більше, ніж хто-небудь інший отримав або, швидше за все, отримає (на основі секретного соусу).

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

Який саме торт без гарної чашки кави?

CoffeeJunkie віддає перевагу каві над шматочком торта, але все-таки хоче спробувати його. Він завжди буде справедливим до інших учасників і намагатиметься згадати, що сталося з останнім пирогом. Однак його надмірне споживання кави послабило його спогади ...

Постійно саботаж, Рубі

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

Це означає, що ви можете перезаписати інші файли, які ви знайдете, які не відображаються у такому форматі. Не слід робити це навмисно, будь ласка, займайтеся спортом.

Цей бот вирішив, що для усунення конкуренції не слід займатися спортом.

Це клон Stately Imitator, за винятком того, що він псує файли стійкості програми Stately Imitator (оскільки вони не мають префіксу з іменем бота), щоб він приймав неправильні рішення і був обраний останнім.

Торговець, 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])
        }

Слідкує за тим, як змінюється співвідношення лівих градусів проти лівого, і коли цей коефіцієнт починає знижуватися, він просить досить справедливий шматочок, інакше просить весь торт, що залишився. Запрошено користуватися 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 (Це був мій день народження, і я плакала тому, що хотів) припускає, що між лівими градусами та кількістю людей, що залишилися, існує залежність. Будемо сподіватися, що це працює!

Слід працювати на всіх пітонах.

Редагувати:

Зберігання sys.argvвходів було трохи марно ...

гість, Python 2

print ord('d')*4

законопроект, Python 2

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

Справедлива ставка.

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

Оскільки AlCakeBot зробив це дуже погано (і я очікую, що він зробить ще гірше у змаганні), ось мій другий запис. Я назвав його « Серфер», тому що він має дуже приємну хвильову функцію вгору-вниз , завдяки якій він відчуває себе серфером.

В принципі, він подає заявки відповідно до cos² (x * pi) , деx частка братого пирога. Ця хвиля серфінгу модифікується за допомогою функції зважування, яка змушує його стартувати менше ніж на справедливу частку менше половини торта, знижує його ставки трохи вище, ніж справедлива частка, коли половина торта піде, а потім прискорює резервне копіювання подати торги на весь торт пізніше. Він ніколи не запропонує менше ніж справедливу частку решти торта плюс 5% (тобто відсоток від усього пирога, тобто).

Зауважте, що, хоча вони можуть бути братами, якщо він отримає значно більший шматочок, ніж AlCakeBot, останній навіть не отримує жодної крихти. Вони поділяли б шоколад чи печиво, але не торт!

Голодний, Ява

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

Завжди хоче справедливу частку торта, що залишився.

Імітатор, Рубі

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

Мета - отримати більше пирога, ніж будь-хто інший, а не максимізувати свій торт. Таким чином, цей бот не погодиться ні на що менше, ніж попередні боти вже взяли. (Ця версія використовує евристику для цієї перевірки. Я щойно помітив, що насправді дозволено зберегти стан, тому я, мабуть, опублікую видатний варіант пізніше).

Дійсно торт, Баш

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

А ось картинка справжнього пирога.

Торт 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));
    }
}

Їсть торт. Ось про це.

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

A basic variant of my other bot, Impatient. This one tries to take the whole thing at first, but as more and more guests get their share, its desire to get the most possible slowly diminishes. I'm not too into this one; just wanna see how well it does.

ALittleExtra, sh

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

I just want a bit more, gets less greedy as cake dwindles

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