Это мой 17-й день рождения, и вы приглашены на мою вечеринку!

И как всегда на вечеринках, будет торт.

Один торт ...

И вам нужно как можно больше этого.

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

Вызов

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

Игровой процесс

• Будет 17 раундов, победителем станет участник с наибольшим количеством побед.
• В случае ничьи, раунды будут играть до тех пор, пока не будет явного победителя.
• Каждый день я буду обновлять текущие оценки, чтобы люди могли обновлять свои записи.

представление

Вы должны написать свою запись как

Имя бота, язык

Insert
Code
Here

Объяснение / Случайные вещи здесь

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

Ваша запись и хранение файлов

• Ваш бот может хранить файлы в ./data/каталоге и больше нигде.
  • Не требуется, но, пожалуйста, храните ваши файлы как botname*
  • Вы не можете писать файлы в этом формате, если botnameэто не имя вашей записи.
  • Это означает, что вам разрешено перезаписывать другие файлы, которые вы не нашли в этом формате. Вы не должны делать это сознательно, пожалуйста, занимайтесь спортом.
  • Ваш бот не должен предполагать, что необходимые ему файлы присутствуют, но он может предполагать, что он ./data/существует.
  • Это потому , что я время от времени протирать ./dataкаталог, я буду делать это , когда обходил на самом деле начать. (Но не между ними)
• Ваш бот может вообще не удалять файлы
• Вашему боту разрешено только читать файлы в ./data/каталоге
  • Это означает, что вы можете посмотреть на другие файлы записей

Полученные результаты:

Кроткий выиграл конкурс! Молодец @ Cabbie407

А теперь немного случайной статистики:

Список позиций, в которые попал каждый бот: (Отлично с любым ботом, фигурирующим в этом списке, вы попали в топ-5 хотя бы раз!)

1. Кроткий, кроткий, эйдетический, эйдетический, кроткий, эйдетический, эйдетический, кроткий, кроткий, кроткий, дерзкий, кроткий, Givemethecake, Givemethecake, Givemethecake, кроткий, 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, RelinFisher

5. счет, MyFairPlusAThird, счет, счет, счет, счет, Relinquisher, Relinquisher, MyFairPlusAThird, счетчик, счет, Reallythecake, счет, ALittleOffTheTop, ALittleOffTheTop, счет, счет

Полный файл журнала для кометы во время работы можно найти здесь . Извините за изменение формата на полпути.

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

Кроткий, awk

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 просто хочет равную долю :(

Он хочет разделить торт равномерно среди всех участников.

(Он полностью ожидает, что другие боты сорвут его, потому что он знает, что они злые)

(Как на самом деле. Он одинок, он просто хочет, чтобы он нравился другим ботам)

(У него только что разорвались плохие отношения, и он проходит через очень грубое пятно, так что, если бы вы просто похлопали его по спине и улыбнулись, чтобы он почувствовал себя лучше, это бы действительно много значило.)

РЕДАКТИРОВАТЬ изменил программу, чтобы принимать входные данные из 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");
    }
}

Он не хочет делать ставки за слишком большой торт, поэтому он выбирает небольшой, но гарантированный случайный кусок.

Пылающая бензопила, Ява

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

Он ждет людей, которые едят приличную долю или меньше, прежде чем съесть какой-нибудь торт. Чтобы жадный не получил лишний пирог, он берет как можно большую порцию.

Боб Баркер, Ява

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

Это, вероятно, будет заменено более продуманным решением позже, но мне интересно, будет ли это работать. Это просто для того, чтобы поймать любых ботов, которые пытаются достичь максимума, и использовать измененную стратегию «Цена - это правильно», чтобы украсть их ответ. Может привести к эскалации с увеличением целочисленных вычитаний, это было бы здорово.

РЕДАКТИРОВАТЬ: эскалация начинается, встречное размещение против FloorBot

Эйдетик, 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 (так как они не имеют префикса с именем бота), так что он принимает неправильные решения и выбирается последним.

Трейдер, Р

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входных данных было немного расточительным ...

гость, питон 2

print ord('d')*4

счет, питон 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 сделал это плохо (и я ожидаю, что он будет еще хуже в конкурсе), вот моя вторая запись. Я назвал его Surfer, потому что у него очень хорошая функция волнения, которая заставляет его чувствовать себя серфером.

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

Обратите внимание, что, хотя они могут быть братьями, если он получит значительно больший срез, чем AlCakeBot, последний даже не получит ни единой крошки этого. Они будут делить шоколад или печенье, но не торт!

Голодный, 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);
    }
}

Всегда хочет свою долю оставшегося торта.

Имитатор, Рубин

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

А вот и картинка настоящего торта.

Торт Пожиратель, Ява

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

Базовый вариант моего другого бота, Нетерпеливый. Сначала он пытается понять все это, но по мере того, как все больше и больше гостей получают свою долю, его желание получить как можно больше медленно уменьшается. Я не слишком в этом; просто хочу посмотреть, как хорошо это делается.

ALittleExtra, sh

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

Я просто хочу немного больше, становлюсь менее жадным, так как торт истощается

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

Очень любит π и думает, что торт средства это π.

Немного вне, 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)

Так как «идеальный» алгоритм пытается равномерно распределить торт между ботами, мы возьмем чуть меньше. Требует полной справедливой доли общего торта, даже в последующих раундах, но искажает это число в сторону увеличения, поскольку оно основано на количестве оставшихся людей.

_{Я не запрограммирован в Python в длинном время, так что дайте мне знать , если мой код сломана ...}