私の17歳の誕生日で、あなたは私のパーティーに招待されています！

そして、いつものように、パーティーがあります。

1つのケーキ...

そして、あなたはそれをできるだけ多く必要とします。

これは公正なパーティーであるため、私たちはそれぞれ、私のケーキをどれだけ欲しいかを言い、最小量を言った人がそれを手に入れると言います。その後、ケーキがなくなるまで他の全員がこのプロセスを繰り返します。

チャレンジ

• の形式のコマンドライン引数を介した入力を指定するとtotal-degrees degrees-left total-people people-left、標準出力に出力されますinteger-bid-in-degrees。
• あなたの入札が最低だった場合、その量のケーキを受け取り、ラウンドに出ます。
• 入札単価が最低ではなかった場合、ボットは残りのケーキに入札します。
• 最低入札価格が同じ場合、削除された人がランダムに選択されます。
• ラウンドの終わりに、すべてのケーキがなくなるか、入札する人がいなくなると、最もケーキを持っている人が勝ちます！
• ラウンドの終わりに2人が同じサイズの最大のスライスを持っている場合、勝者は抽選からランダムに選ばれます。

ゲームプレイ

• 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、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、Relinquisher、Bill、Bill、Fillquirher

5. ビル、MyFairPlusAThird、ビル、ビル、ビル、ビル、ビル、放棄者、放棄者、MyFairPlusAThird、放棄者、ビル、Reallythecake、ビル、ALittleOffTheTop、ALittleOffTheTop、ビル、ビル

実行中の彗星の完全なログファイルはここにあります。途中でフォーマットが変更されて申し訳ありません。

コンテストを再度実行することはありません。さらにエントリを投稿したい場合は、このコンテストのgithubリポジトリでコントローラーを見つけることができます。

ミーク、awk

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

これはシミュレーションで一度見ました。

マジシャン、Java

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

番号720は魔法です。

_{これはコントローラーをテストするためのものであり、重大なエントリではありません。}

スリム、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は、等しい部分のみを必要としています:(

彼はすべての参加者の間でケーキを均等に分割したいと考えています。

（彼は、他のボットが彼をはぎ取ると完全に期待していますが、それは彼らが意地悪だと知っているからです）

（本当に好きです。彼は孤独で、他のボットに彼を好きになってほしいだけです）

（彼は悪い関係から抜け出し、本当に荒いパッチを経験しているので、あなたが彼に背中を軽くたたき、彼が気分が良くなるように笑顔を与えることができれば、それは本当に多くのことを意味します。）

編集は、stdinの代わりにargv / cから入力を取得するようにプログラムを変更しました（公正なボットはまだ悲しいです...彼は自分の名前を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ケーキのリクエストと見なし、実際にはケーキのサイズに追加しません）

風格のある模倣者、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))

Imitatorのバリアント（プレイヤーごとに1つのエントリのみを希望する場合、これはそのエントリに優先します）。すでに取得した最大のスライスを正確に追跡し、常にそのスライスを打ち負かすのに十分な値を付けます。また、残りの公正なシェアよりも低く入札することはありません。読み取り/書き込み可能な「./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]);}
    }
}

チェーンソーでケーキカットコンテストを開催したことがありますか？さて、あなたは今持っています。むしろ破壊的です。

紳士、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;
    }
}

彼はケーキを食べる前にかなりのシェア以下を食べる人を待っています。欲張りが余分なケーキを手に入れるのを防ぐために、彼はできるだけ多くの部分を取ります。

ボブ・バーカー、ジャワ

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

これはおそらくもっと考え抜かれた解決策に後で置き換えられるでしょうが、これがうまくいくかどうか興味があります。これは、最大を目指してボットをキャッチし、修正されたPrice is Right戦略を実行して回答を盗むためのものです。整数の減算が増えるとエスカレーションが発生する可能性があります。

編集：エスカレーションが開始され、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（私の誕生日であり、私が望んでいたので泣きました）は、残された学位と残された人数の間に関係があると仮定しています。うまくいくことを期待しましょう！

すべてのPythonで動作するはずです。

編集：

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の成績は非常に悪かったので（そして、彼がコンテストでさらに悪い成績を収めることが期待されます）、ここに私の2番目のエントリがあります。彼をサーファーと呼んだのは、彼がサーファーのように感じる非常に素晴らしい上下の波動関数を持っているからです。

原則として、彼はに従って入札します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

そして、これが本物のケーキの写真です。

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

ケーキを食べる。それについてです。

放棄者、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);
    }
}

私の他のボット、Impatientの基本的なバリアント。これは最初はすべてを取得しようとしますが、より多くのゲストがシェアを獲得するにつれて、可能な限りゆっくり取得したいという欲求は減少します。私はこれにあまり興味がありません。それがどれだけうまくいくかを見たいだけです。

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

本当にπが好きで、ケーキだと思う 手段 ある π。

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)

「完璧な」アルゴリズムは、ボット間でケーキを均等に分割しようとするため、それよりも少ないスライバーを使用します。後続のラウンドでもケーキ全体の公正なシェアを要求しますが、残された人数に基づいているため、その数は上方に偏っています。

_{私は長い間Pythonでプログラミングしていないので、コードが壊れているかどうかを教えてください...}