Đó là sinh nhật lần thứ 17 của tôi và bạn được mời đến bữa tiệc của tôi!

Và như mọi khi trong các bữa tiệc, sẽ có bánh.

Một chiếc bánh ...

Và bạn cần càng nhiều nó càng tốt.

Vì đây là một bữa tiệc công bằng, mỗi người trong chúng ta sẽ nói chúng ta muốn bao nhiêu bánh và người nói số tiền nhỏ nhất sẽ nhận được. Sau đó, mọi người khác sẽ lặp lại quá trình cho đến khi chiếc bánh đã biến mất.

Thử thách

• Đưa ra đầu vào thông qua các đối số dòng lệnh ở dạng total-degrees degrees-left total-people people-left, đầu ra thành đầu ra tiêu chuẩn integer-bid-in-degrees.
• Nếu giá thầu của bạn thấp nhất, bạn sẽ nhận được số lượng bánh đó và sẽ ra khỏi vòng đấu.
• Nếu giá thầu của bạn không thấp nhất, bot của bạn sẽ trả giá cho chiếc bánh còn lại.
• Trong trường hợp giá thầu thấp nhất là như nhau, người bị xóa sẽ được chọn ngẫu nhiên.
• Kết thúc một vòng, một khi tất cả các bánh đã biến mất hoặc không còn ai để trả giá cho nó, người có nhiều bánh nhất sẽ thắng!
• Trong trường hợp ở cuối vòng và hai người có cùng một lát lớn nhất, người chiến thắng được chọn ngẫu nhiên từ các mục vẽ.

Trò chơi

• Sẽ có 17 vòng, người chiến thắng chung cuộc sẽ là người có nhiều chiến thắng nhất.
• Trong trường hợp bốc thăm, các vòng sẽ được chơi cho đến khi có một người chiến thắng rõ ràng.
• Mỗi ngày, tôi sẽ cập nhật điểm số hiện tại để mọi người có thể nâng cấp mục nhập của họ.

Nộp hồ sơ

Bạn nên viết mục của bạn là

Tên Bot, Ngôn ngữ

Insert
Code
Here

Giải thích / công cụ ngẫu nhiên ở đây

Nếu mục nhập của bạn không được định dạng theo cách này, bộ điều khiển sẽ KHÔNG thể chạy mục nhập của bạn. Nếu tôi thấy điều này đã xảy ra với mục nhập của bạn, tôi sẽ thông báo cho bạn trong một nhận xét và / hoặc chỉnh sửa câu trả lời thành định dạng chính xác.

Mục nhập và lưu trữ tệp của bạn

• Bot của bạn có thể lưu trữ các tập tin trong ./data/thư mục và không nơi nào khác.
  • Không bắt buộc nhưng vui lòng lưu trữ tệp của bạn dưới dạng botname*
  • Bạn không thể viết các tập tin ở định dạng này nếu botnamekhông phải là tên mục nhập của bạn.
  • Điều này có nghĩa là bạn được phép ghi đè lên các tệp khác mà bạn thấy không xuất hiện ở định dạng này. Bạn không nên cố tình làm điều này, hãy thể thao.
  • Bot của bạn không được cho rằng các tệp mà nó yêu cầu có mặt nhưng nó có thể giả sử ./data/tồn tại.
  • Điều này là do tôi thỉnh thoảng xóa ./datathư mục, tôi sẽ làm điều này khi các vòng thực sự bắt đầu. (Nhưng không phải giữa họ)
• Bot của bạn hoàn toàn không thể xóa các tập tin
• Bot của bạn chỉ được phép đọc các tập tin trong ./data/thư mục
  • Điều này có nghĩa là bạn có thể xem các tệp mục khác

Các kết quả:

Meek đã thắng cuộc thi! Làm tốt lắm @ Cabbie407

Và bây giờ đối với một số thống kê ngẫu nhiên:

Một danh sách các vị trí mà mỗi bot xuất hiện: (Hoàn thành tốt với bất kỳ bot nào xuất hiện trong danh sách này, bạn đã lọt vào top 5 ít nhất một lần!)

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, MyFairPlusAThird

3. Realthecake, AlCakeSurfer, AlCakeSurfer, Meek, AlCakeSurfer, Meek, AlCakeSurfer, AlCakeSurfer, reallythecake, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eid, Eidetic

4. AlCakeSurfer, reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlus,

5. bill, MyFairPlusAThird, bill, bill, bill, bill, Relrowisher, Relrowisher, MyFairPlusAThird, Relrowisher, bill, reallythecake, bill, ALittle OfferTheTop, ALittle OfferTheTop, bill, bill

Tệp nhật ký đầy đủ cho sao chổi trong khi chạy có thể được tìm thấy ở đây . Xin lỗi về việc thay đổi định dạng giữa chừng.

Tôi sẽ không chạy lại cuộc thi, nếu bạn muốn đăng thêm mục, bạn có thể làm như vậy, bộ điều khiển có thể được tìm thấy trên repo github của tôi cho cuộc thi này .

Mẹ ơi

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

Tôi đã thấy điều này một lần trong một mô phỏng.

Nhà ảo thuật, Java

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

Số 720 là huyền diệu.

_{Đây là chỉ là thử những bộ điều khiển và là không một mục nghiêm trọng.}

Mỏng, Python 2

print 0

Bot này đang ăn kiêng.

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

Trước đây là FairBot

FairBot chỉ muốn một phần bằng nhau :(

Anh ấy muốn chia đều bánh cho tất cả những người tham gia.

(Anh ấy hoàn toàn mong đợi các bot khác sẽ loại bỏ anh ấy bởi vì anh ấy biết chúng có ý nghĩa)

(Giống như thực sự. Anh ấy cô đơn, anh ấy chỉ muốn các bot khác thích anh ấy)

(Anh ấy vừa thoát khỏi một mối quan hệ tồi tệ và đang trải qua một bản vá thực sự thô bạo, vì vậy nếu bạn có thể vỗ nhẹ vào lưng anh ấy và mỉm cười để anh ấy cảm thấy tốt hơn thì điều đó thực sự có ý nghĩa rất nhiều.)

EDIT đã thay đổi chương trình để lấy đầu vào từ argv / c thay vì stdin (bot công bằng vẫn buồn .... Anh ấy muốn đổi tên thành sadbot (đó là lý do tại sao anh ấy muốn bánh))

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

Nghiêm túc, công bằng không thể tin được. Một nửa bánh cho tôi, một nửa bánh cho những người khác.

CharityBot, Python 2

print -360

Thêm một chiếc bánh khác vào hỗn hợp!

(Bộ điều khiển sẽ xem đây là yêu cầu cho 0 bánh, sẽ không thực sự thêm vào kích thước của bánh)

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

Biến thể của Imitator (nếu bạn chỉ muốn một mục nhập cho mỗi người chơi, thì điều này thay thế cho mục đó). Theo dõi chính xác lát cắt lớn nhất đã được thực hiện và luôn trả giá đủ để đánh bại lát cắt đó. Cũng sẽ không bao giờ trả giá thấp hơn phần còn lại của nó. Giả sử thư mục './data' đã đọc / ghi được; các tập tin có thể ở đó hoặc không.

Ăn kiêng, Java

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

Nó không muốn trả giá quá nhiều bánh, vì vậy nó chọn một lát ngẫu nhiên nhỏ nhưng được đảm bảo .

Cưa xích, 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]);}
    }
}

Bạn đã bao giờ thử tổ chức một cuộc thi cắt bánh với cưa máy chưa? Vâng, bây giờ bạn có. Nó khá là quậy phá.

Quý ông, 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;
    }
}

Anh ấy chờ đợi những người ăn chia sẻ công bằng hoặc ít hơn trước khi anh ấy ăn bất kỳ chiếc bánh nào. Để ngăn chặn những kẻ tham lam lấy thêm bánh, anh ta lấy một phần càng lớn càng tốt.

Bob Barker, Java

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

Điều này có thể sẽ được thay thế bằng một giải pháp chu đáo hơn sau này, nhưng tôi tò mò liệu điều này có hiệu quả không. Đây chỉ là để bắt bất kỳ bot nào cố gắng và đi tối đa, và thực hiện chiến lược Price is Right đã sửa đổi để đánh cắp câu trả lời của chúng. Có thể dẫn đến leo thang với phép trừ số nguyên tăng dần, điều đó sẽ gọn gàng.

EDIT: Bắt đầu nâng cấp, đăng bài chống lại 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()

Tôi đã chạy bot này trong bộ điều khiển một vài lần để huấn luyện nó một chút, nó nhớ các giá thầu cần thiết để giành chiến thắng trong mỗi vòng và sau khi được đào tạo, nó đi ra thế giới thực và bỏ phiếu với phần còn lại của chúng.

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

Đây là bài viết PCG đầu tiên của tôi; Tôi hy vọng việc này diễn ra như dự định

Tôi yêu bánh. Bất kể loại nào. Các đồng nghiệp của tôi biết. Và bot của tôi cũng vậy. Nếu toàn bộ chiếc bánh vẫn còn đó, anh ta sẽ trả giá chỉ dưới một nửa số đó, hy vọng sẽ có được miếng bánh lớn nhất ngay lập tức. Nếu không, anh ta nên trả giá cho một cái gì đó giữa một nửa số bánh còn lại và tất cả các bánh còn lại, sử dụng một hình sin vuông làm hàm trọng số ( ½ + sin² (fraction gone) / 2). Lý do là nên có một cơ hội cho một lát cắt tổng thể lớn hơn (nhưng nhỏ hơn một chút) vào đầu trò chơi và cũng có rất ít điểm để cố gắng trở thành một quý ông trong trò chơi muộn.

Vì tôi không có nhiều về lập trình, tôi sẽ đánh giá cao bất kỳ lỗi nào được chỉ ra. Bây giờ chúng ta hãy ăn một ít bánh = 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 sẵn sàng chấp nhận ít hơn một nửa số bánh còn lại, miễn là nó nhiều hơn bất kỳ ai khác nhận được hoặc có khả năng nhận được (dựa trên nước sốt bí mật).

Cà phêJunkie, 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..]...))

Chính xác thì một chiếc bánh không có tách cà phê ngon là gì?

CoffeeJunkie thích cà phê hơn một lát bánh, nhưng vẫn muốn thử một ít. Anh ấy sẽ luôn công bằng với những người tham gia khác và sẽ cố gắng nhớ những gì đã xảy ra với chiếc bánh cuối cùng. Tuy nhiên, việc tiêu thụ quá nhiều cà phê của anh đã làm suy yếu ký ức của anh ...

Phá hoại nghiêm túc, 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))

Điều này có nghĩa là bạn được phép ghi đè lên các tệp khác mà bạn thấy không xuất hiện ở định dạng này. Bạn không nên cố tình làm điều này, hãy thể thao.

Bot này đã quyết định rằng để loại bỏ sự cạnh tranh, nó không nên thể thao.

Đây là một bản sao của Stantly Imitator, ngoại trừ việc cái này làm rối các tập tin lưu giữ của Stantly Imitator (vì chúng không có tiền tố với tên bot) để nó đưa ra quyết định sai và được chọn cuối cùng.

Thương nhân, 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])
        }

Theo dõi sự tiến hóa của độ trái so với tỷ lệ trái của người và khi tỷ lệ đó bắt đầu hạ xuống, nó yêu cầu một lát cắt hợp lý, nếu không thì yêu cầu toàn bộ chiếc bánh còn lại. Yêu cầu sử dụng 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 (Đó là ngày sinh nhật của tôi và tôi đã khóc vì tôi muốn) cho rằng có một mối quan hệ giữa các độ còn lại và số người còn lại. Hãy hy vọng nó hoạt động!

Nên làm việc trong tất cả các Pythons.

Chỉnh sửa:

Lưu trữ sys.argvtrong đầu vào là một chút lãng phí ...

khách, Python 2

print ord('d')*4

hóa đơn, Python 2

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

Một vụ cá cược công bằng.

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

Vì AlCakeBot đã làm rất tệ (và tôi hy vọng anh ấy sẽ còn tệ hơn trong cuộc thi) đây là mục thứ hai của tôi. Tôi gọi anh ta là Surfer, bởi vì anh ta có chức năng sóng lên xuống rất đẹp khiến anh ta cảm thấy như một người lướt sóng.

Về nguyên tắc, anh trả giá theo cos² (x * pi), ở đâux là phần bánh đã được lấy. Làn sóng lướt sóng này được sửa đổi với chức năng tăng trọng lượng khiến anh ta bắt đầu ít hơn một phần công bằng chưa đến một nửa chiếc bánh, giảm giá thầu của anh ta xuống chỉ trên một phần công bằng xung quanh khi một nửa chiếc bánh biến mất, và sau đó tăng tốc trở lại để đấu thầu cho toàn bộ bánh sau này. Anh ta sẽ không bao giờ trả giá thấp hơn một phần công bằng của chiếc bánh còn lại cộng thêm 5% (nghĩa là phần trăm của toàn bộ chiếc bánh).

Lưu ý rằng trong khi họ có thể là anh em, nếu anh ta có được một lát lớn hơn đáng kể so với AlCakeBot, thì sau này thậm chí còn không nhận được một mẩu vụn nào. Họ sẽ chia sẻ sô cô la hoặc bánh quy, nhưng không phải bánh!

Đói, 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);
    }
}

Luôn muốn chia sẻ công bằng của nó của bánh còn lại.

Kẻ bắt chước, 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))

Mục tiêu là để có được nhiều bánh hơn bất kỳ ai khác, không phải để tối đa hóa bánh của bạn. Do đó, bot này sẽ không giải quyết ít hơn những gì các bot trước đây đã thực hiện. (Phiên bản này sử dụng phương pháp phỏng đoán cho kiểm tra đó. Tôi chỉ nhận thấy rằng chúng tôi thực sự được phép lưu trạng thái nên có thể tôi sẽ đăng một biến thể trạng thái sau).

Thực sự là bánh, Bash

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

Và đây là hình ảnh của chiếc bánh thật.

Bánh ăn, 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));
    }
}

Nó ăn bánh. Đó là về nó.

Người từ bỏ, 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);
    }
}

Một biến thể cơ bản của bot khác của tôi, thiếu kiên nhẫn. Điều này ban đầu cố gắng lấy toàn bộ mọi thứ, nhưng khi càng nhiều khách nhận được phần của họ, mong muốn của họ để có được những điều chậm nhất có thể giảm dần. Tôi không quá thích cái này; chỉ muốn xem nó tốt như thế nào

ALittleExtra, sh

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

Tôi chỉ muốn nhiều hơn một chút, bớt tham lam hơn khi bánh giảm dần

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

Thực sự thích π, và nghĩ rằng bánh có nghĩa là π.

Một chút tắt đầu, 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)

Vì thuật toán "hoàn hảo" cố gắng phân chia bánh đều giữa các bot, chúng tôi sẽ chỉ lấy một phần nhỏ hơn thế. Yêu cầu chia sẻ toàn bộ công bằng của nó về bánh tổng thể, ngay cả trong các vòng tiếp theo, nhưng nghiêng số đó lên vì nó dựa trên số lượng người còn lại.

_{Tôi đã không lập trình được Python trong một thời gian dài , vì vậy hãy cho tôi biết nếu mã của tôi bị hỏng ...}