Ini ulang tahun ke 17 saya dan Anda diundang ke pesta saya!

Dan seperti biasa di pesta-pesta, akan ada kue.

Satu kue ...

Dan Anda membutuhkannya sebanyak mungkin.

Karena ini adalah pesta yang adil, kita masing-masing akan mengatakan berapa banyak kue yang kita inginkan dan orang yang mengatakan jumlah terkecil akan mendapatkannya. Kemudian semua orang dapat mengulangi prosesnya sampai kue hilang.

Tantangan

• Diberikan input melalui argumen baris perintah dalam bentuk total-degrees degrees-left total-people people-left, output ke output standar integer-bid-in-degrees.
• Jika tawaran Anda adalah yang terendah, Anda menerima jumlah kue itu dan keluar untuk putaran itu.
• Jika tawaran Anda tidak terendah, bot Anda dapat menawar kue yang tersisa.
• Dalam hal tawaran terendah sama, orang yang dihapus akan dipilih secara acak.
• Di akhir ronde, setelah semua kue habis atau tidak ada yang tersisa untuk menawar, orang dengan kue terbanyak menang!
• Dalam kasus di akhir putaran dan dua orang memiliki irisan terbesar berukuran sama, pemenang dipilih secara acak dari entri gambar.

Gameplay

• Akan ada 17 putaran, pemenang keseluruhan akan menjadi entri dengan kemenangan terbanyak secara keseluruhan.
• Dalam hal pengundian, putaran akan dimainkan sampai ada pemenang yang jelas.
• Setiap hari, saya akan memperbarui skor saat ini sehingga orang dapat meningkatkan entri mereka.

pengajuan

Anda harus menulis entri Anda sebagai

Nama Bot, Bahasa

Insert
Code
Here

Penjelasan / Acak hal di sini

Jika entri Anda tidak diformat dengan cara ini, controller TIDAK akan dapat menjalankan entri Anda. Jika saya menemukan ini terjadi pada entri Anda, saya akan memberi tahu Anda dalam komentar, dan / atau mengedit jawaban ke dalam format yang benar.

Entri dan penyimpanan file Anda

• Bot Anda dapat menyimpan file di ./data/direktori dan tempat lain.
  • Tidak diperlukan tetapi harap simpan file Anda sebagai botname*
  • Anda tidak boleh menulis file dalam format ini jika botnamebukan nama entri Anda.
  • Ini berarti Anda diizinkan untuk menimpa file lain yang Anda temukan yang tidak muncul dalam format ini. Anda tidak seharusnya melakukan ini dengan sengaja, harap berolahraga.
  • Bot Anda tidak boleh berasumsi bahwa file-file yang dibutuhkannya ada tetapi ia dapat menganggap ./data/ada.
  • Ini karena saya sesekali menghapus ./datadirektori, saya akan melakukan ini ketika putaran benar-benar dimulai. (Tapi tidak di antara mereka)
• Bot Anda mungkin tidak menghapus file sama sekali
• Bot Anda hanya diperbolehkan membaca file di ./data/direktori
  • Ini berarti Anda dapat melihat file entri lainnya

Hasil:

Lemah lembut memenangkan kontes! Bagus @ Cabbie407

Dan sekarang untuk beberapa statistik acak:

Daftar posisi setiap bot masuk: (Dilakukan dengan baik untuk bot apa pun yang muncul dalam daftar ini, Anda berada di 5 teratas setidaknya satu kali!)

1. Lemah, Lemah, Eidetik, Lemah, Lemah, Lemah, Lemah, Lemah, Lemah, Lemah, Lemah, Givemethecake, Givemethecake, Givemethecake, Lemah, Eidetic

2. Eidetic, Eidetic, Meek, AlCakeSurfer, Eidetic, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, MyFairPlusAThird, MyFairPlusAThird, Meek, MyFairPlusAThird, AlFakePurfer

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

4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Mydair, bill, Ferher, Adher

5. tagihan, MyFairPlusAThird, tagihan, tagihan, tagihan, tagihan, Rilis

File log lengkap untuk cometition saat berjalan dapat ditemukan di sini . Maaf tentang perubahan format setengah jalan.

Saya tidak akan menjalankan kontes lagi, jika Anda ingin memposting lebih banyak entri, Anda dapat melakukannya, controller dapat ditemukan di repo github saya untuk kontes ini .

Lemah, awk

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

Saya melihat ini sekali dalam simulasi.

Pesulap, Jawa

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

Angka 720 ajaib.

_{Ini adalah dimaksudkan untuk menguji controller dan tidak entri serius.}

Slim, Python 2

print 0

Bot ini sedang diet.

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

Sebelumnya FairBot

FairBot hanya menginginkan porsi yang sama :(

Dia ingin membagi kue secara merata di antara semua peserta.

(Dia sepenuhnya mengharapkan bot lain untuk merobeknya karena dia tahu itu jahat)

(Seperti benar-benar. Dia kesepian, dia hanya ingin bot lain menyukainya)

(Dia baru saja keluar dari hubungan yang buruk dan sedang mengalami masa sulit, jadi jika Anda bisa memberinya tepukan di punggung dan senyuman untuk membuatnya merasa lebih baik itu akan sangat berarti.)

EDIT mengubah program untuk mengambil input dari argv / c alih-alih stdin (bot yang adil masih sedih .... Dia ingin mengubah namanya menjadi sadbot (itulah sebabnya dia ingin kue))

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

Sangat adil, sangat adil. Setengah kue untukku, setengah kue untuk semua orang.

CharityBot, Python 2

print -360

Tambahkan kue lain ke dalam campuran!

(Pengontrol akan melihat ini sebagai permintaan 0 kue, tidak akan benar-benar menambah ukuran kue)

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

Varian dari Imitator (jika Anda lebih suka hanya satu entri per pemain, ini menggantikan yang satu itu). Terus melacak irisan terbesar yang diambil, dan selalu cukup tawaran untuk mengalahkan irisan itu. Juga tidak akan pernah menawar lebih rendah dari bagian sisanya yang adil. Mengasumsikan direktori './data' sudah dibaca / dapat ditulis; file dapat sudah ada di sana atau tidak.

Dieter, Jawa

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

Itu tidak ingin menawar terlalu banyak kue, jadi ia memilih sepotong acak kecil tapi dijamin .

Flaming Chainsaw, 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]);}
    }
}

Pernahkah Anda mencoba mengadakan kontes pemotongan kue dengan gergaji mesin? Nah, sekarang sudah. Agak mengganggu.

Tuan-tuan, Jawa

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

Dia menunggu orang yang makan dengan porsi yang adil atau kurang sebelum dia makan kue apa pun. Untuk mencegah serakah dari mendapatkan kue tambahan, ia mengambil porsi sebesar mungkin.

Bob Barker, Jawa

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

Ini mungkin akan diganti dengan solusi yang lebih dipikirkan nanti, tapi saya ingin tahu apakah ini akan berhasil. Ini hanya untuk menangkap bot yang mencoba dan pergi secara maksimal, dan melakukan strategi Price is Right yang dimodifikasi untuk mencuri jawaban mereka. Mungkin mengarah pada peningkatan dengan pengurangan bilangan bulat yang meningkat, itu akan menjadi rapi.

EDIT: Eskalasi dimulai, kontra-posting terhadap FloorBot

Eidetik, 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()

Saya menjalankan bot ini di pengontrol beberapa kali untuk melatihnya sedikit, ia mengingat tawaran yang diperlukan untuk memenangkan setiap putaran dan kemudian setelah dilatih, ia pergi ke dunia nyata dan memberikan suara dengan sisanya.

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

Ini adalah posting PCG pertama saya; Saya harap ini berhasil sebagaimana dimaksud ...

Saya suka kue. Apa pun jenisnya. Rekan-rekan saya tahu. Dan bot saya juga demikian. Jika seluruh kue masih ada, dia akan menawar hanya setengahnya, berharap mendapatkan potongan terbesar segera. Jika tidak, ia harus menawar sesuatu antara setengah kue yang tersisa dan semua kue yang tersisa, menggunakan sinus kuadrat sebagai fungsi pembobotan (½ + sin² (fraction gone) / 2 ). Alasannya adalah bahwa harus ada kesempatan untuk irisan yang lebih besar secara keseluruhan (tetapi fraksional lebih kecil) di awal permainan dan ada juga gunanya mencoba menjadi pria sejati di akhir permainan.

Karena saya tidak terlalu suka pemrograman, saya akan menghargai kesalahan yang ditunjukkan Sekarang mari kita makan kue = D

Cakep, 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 bersedia menerima sedikit kurang dari setengah dari kue yang tersisa, asalkan lebih dari yang didapat atau kemungkinan diperoleh orang lain (berdasarkan saus rahasia).

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

Apa sebenarnya kue tanpa secangkir kopi yang enak?

CoffeeJunkie lebih suka kopi daripada sepotong kue, tetapi tetap ingin mencobanya. Dia akan selalu bersikap adil kepada peserta lain dan akan mencoba mengingat apa yang terjadi pada kue terakhir. Namun, konsumsi kopi yang berlebihan telah melemahkan ingatannya ...

Sabotase Megah, 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))

Ini berarti Anda diizinkan untuk menimpa file lain yang Anda temukan yang tidak muncul dalam format ini. Anda tidak seharusnya melakukan ini dengan sengaja, harap berolahraga.

Bot ini memutuskan bahwa untuk menghilangkan persaingan, tidak boleh olahraga.

Ini adalah tiruan dari Stately Imitator, kecuali yang ini mengacaukan file kegigihan Stately Imitator (karena mereka tidak diawali dengan nama bot) sehingga membuat keputusan yang salah dan dipilih terakhir.

Trader, 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])
        }

Melacak evolusi derajat kiri vs rasio orang yang tersisa dan ketika rasio itu mulai menurun, ia meminta potongan yang cukup adil, jika tidak meminta seluruh kue yang tersisa. Diminta menggunakan 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 (Itu adalah hari ulang tahun saya dan saya menangis karena saya ingin) berasumsi bahwa ada hubungan antara derajat yang tersisa dan jumlah orang yang tersisa. Semoga berhasil!

Harus bekerja di semua Python.

Edit:

Menyimpan sys.argvinput agak boros ...

tamu, Python 2

print ord('d')*4

tagihan, Python 2

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

Taruhan yang adil.

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

Karena AlCakeBot melakukannya dengan sangat buruk (dan saya berharap dia melakukan lebih buruk dalam kontes) inilah entri kedua saya. Saya memanggilnya Surfer, karena ia memiliki fungsi gelombang naik-turun yang sangat bagus yang membuatnya merasa seperti peselancar.

Pada prinsipnya, ia menawar sesuai dengan cos² (x * pi), di manax fraksi kue yang telah diambil. Gelombang selancar ini dimodifikasi dengan fungsi pembobotan yang menyebabkannya mulai dengan kurang dari bagian yang adil kurang dari setengah dari kue, mengurangi tawarannya hingga tepat di atas bagian yang adil sekitar ketika setengah dari kue itu hilang, dan kemudian mempercepat kembali untuk menawar seluruh kue nanti. Dia tidak akan pernah menawar kurang dari bagian yang adil dari kue yang tersisa ditambah 5% (persen dari seluruh kue, yaitu).

Perhatikan bahwa meskipun mereka mungkin bersaudara, jika dia mendapatkan irisan yang jauh lebih besar daripada AlCakeBot, yang terakhir bahkan tidak mendapatkan remah tunggal itu. Mereka akan berbagi cokelat atau biskuit, tetapi bukan kue!

Lapar, Jawa

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

Selalu ingin bagian yang adil dari kue yang tersisa.

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

Tujuannya adalah untuk mendapatkan lebih banyak kue daripada orang lain, bukan untuk memaksimalkan kue Anda. Dengan demikian, bot ini tidak akan puas dengan apa yang telah diambil bot sebelumnya. (Versi ini menggunakan heuristik untuk pemeriksaan itu, saya baru saja memperhatikan bahwa kita benar-benar diizinkan untuk menyimpan status jadi saya mungkin akan memposting varian stateful nanti).

Sungguh kue, Bash

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

Dan ini adalah gambar kue asli.

Pemakan Kue, Jawa

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

Itu makan kue. Itu saja.

Relinquisher, Jawa

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

Varian dasar bot saya yang lain, Tidak Sabar. Yang ini mencoba untuk mengambil semuanya pada awalnya, tetapi karena semakin banyak tamu mendapatkan bagian mereka, keinginannya untuk mendapatkan yang paling mungkin perlahan-lahan berkurang. Saya tidak terlalu suka yang ini; hanya ingin melihat seberapa baik itu.

ALittleExtra, sh

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

Saya hanya ingin sedikit lebih, menjadi lebih serakah seperti kue berkurang

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

Sangat suka π, dan berpikir kue itu cara adalah π.

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)

Karena algoritme "sempurna" mencoba untuk membagi kue secara merata di antara bot, kami hanya akan mengambil sepotong lebih sedikit dari itu. Menuntut bagian penuh keseluruhan dari kue keseluruhan, bahkan di putaran berikutnya, tetapi condongkan angka itu ke atas karena didasarkan pada berapa banyak orang yang tersisa.

_{Saya belum diprogram dalam Python dalam panjang sementara, jadi biar tahu jika kode saya rusak ...}