这是我的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，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，RelinquishersPlus，帐单，账单，

5. 法案，MyFairPlusAThird，法案，法案，法案，法案，Relinquisher，法案，MyFairPlusAThird，Relinquisher，法案，Reallythecake，法案，ALittleOffTheTop，ALittleOffTheTop，法案，法案

可以在此处找到运行时彗星的完整日志文件。抱歉，格式更改尚需时日。

我将不再运行竞赛，如果您想发布更多条目，欢迎这样做，可以在我的github仓库中找到该竞赛的控制器。

Aeek，Meek

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是神奇的数字。

_{这是为了测试控制器，而不是一个严肃的条目。}

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接受输入（公平的bot仍然很伤心。...他想将自己的名字更改为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))

模仿者的变体（如果您只希望每个玩家只有一个条目，那么它将取代那个条目）。精确跟踪已拍摄的最大片段，并始终出价足以击败该片段。出价也永远不会低于其剩余部分的合理份额。假设一个可读写的“ ./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;
    }
}

他在吃任何蛋糕之前，先等一等量或更少的人。为了防止贪婪的人得到额外的蛋糕，他尽可能多地使用。

Java的Bob Barker

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

以后可能会用更深思熟虑的解决方案代替它，但是我很好奇这是否可行。这只是为了抓住所有尝试最大化的机器人，并进行修改后的“价格就是正确”策略来窃取他们的答案。可能会随着整数减法的增加而逐步升级，那会很整洁。

编辑：升级开始，针对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))

Saucy愿意接受剩下的蛋糕的一半以下，只要它比别人获得或可能得到的更多（基于秘密调味料）。

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的持久性文件弄乱了（因为它们没有以bot名称为前缀），以便做出错误的决定并最终选择。

交易员，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的表现如此糟糕（我希望他在比赛中表现更糟），这是我的第二次参赛。我称他为Surfer，是因为他具有很好的上下波动功能，使他感觉像冲浪者。

原则上，他根据进行出价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);
    }
}

总是希望其在剩余蛋糕中的份额合理。

模仿者，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))

目标是获得比别人更多的蛋糕，而不是使蛋糕最大化。因此，该机器人的解决方案不会比以前的机器人已经满足。（此版本使用启发式方法进行检查，我刚刚注意到实际上可以保存状态，因此稍后可能会发布有状态的变体）。

真的是蛋糕，Bash

#!/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));
    }
}

它吃蛋糕。就是这样

Java Relinquisher

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编程了，所以让我知道我的代码是否损坏...}