Bu benim 17. doğum günüm ve sen benim partime davetlisin!

Partilerde her zaman olduğu gibi, kek olacak.

Bir pasta ...

Ve mümkün olduğunca buna ihtiyacınız var.

Bu adil bir parti olduğu için, her birimiz ne kadar istediğimizi ve en küçük miktarı söyleyen kişinin alacağını söyleyeceğiz. Sonra herkes pastayı gidene kadar işlemi tekrar eder.

Meydan okuma

• Komut satırı argümanları aracılığıyla girdi total-degrees degrees-left total-people people-left, standart çıktıya çıktı verilir integer-bid-in-degrees.
• Eğer teklifiniz en düşük ise, o kadar miktarda kek alırsınız ve raund için verilir.
• Teklifiniz düşük değilse, botunuz kalan pastayı teklif eder.
• En düşük tekliflerin aynı olması durumunda, kaldırılan kişi rastgele seçilecektir.
• Bir turun sonunda, tüm pastalar gittiğinde veya teklif verecek kimse kalmamışsa, en çok pastayı veren kişi kazanır!
• Bir turun sonunda ve iki kişinin aynı büyüklükteki en büyük dilime sahip olması durumunda, kazanan çizim girişlerinden rastgele seçilir.

Oynanış

• 17 tur olacak, genel galip genel galibiyet en fazla galibiyete girecek.
• Beraberlik durumunda, açık bir kazanan olana kadar turlar oynanacaktır.
• Her gün, mevcut skorları güncelleyerek insanların girişlerini yükseltmelerini sağlayacağım.

boyun eğme

Girişinizi aşağıdaki gibi yazmalısınız.

Bot Adı, Dil

Insert
Code
Here

Açıklama / Burada rastgele şeyler

Girişiniz bu şekilde biçimlendirilmezse, denetleyici girişinizi çalıştıramaz. Bunun girişinize geldiğini tespit edersem, ya bir yorumda sizi bilgilendiririm ve / veya cevabı doğru formatta düzenlerim.

Giriş ve dosya deponuz

• Botunuz dosyaları ./data/dizinde ve başka hiçbir yerde saklayabilir .
  • Gerekli değil, ancak lütfen dosyalarınızı saklayın botname*
  • botnameGiriş adınız değilse , dosyaları bu biçimde yazamazsınız .
  • Bu, bu biçimde görünmeyen diğer dosyaların üzerine yazmanıza izin verildiği anlamına gelir. Bunu kasten yapmamalısın, lütfen sportif ol.
  • Botunuz, ihtiyaç duyduğu dosyaların var olduğunu varsaymamalı, ancak ./data/var olduğunu varsayabilir .
  • Bu Arada silin çünkü ./datadizin, ben edecek mermi aslında başladığınızda bunu. (Ama aralarında değil)
• Botunuz hiç dosya silemiyor olabilir
• Botunuz yalnızca ./data/dizindeki dosyaları okuyabilir
  • Bu demektir olabilecek diğer girdiler dosyalarına bakmak

Sonuçlar:

Meek yarışmayı kazandı! Aferin @ Cabbie407

Ve şimdi bazı rastgele istatistikler için:

Her botun pozisyonlarının bir listesi geldi: (Bu listede görünen botlara aferin, ilk 5'e en az bir kere geldiniz!)

1. Meek, Meek, Eidetik, Eidetik, Meek, Eidetik, Eidetik, Meek, Meek, Meek, Şımarık, Meek, Givemethecake, Givemethecake, Givemethecake, Meek, Eidetic

2. Eidetik, Eidetik, Meek, AlCakeSurfer, Eidetik, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetik, Eidetik, Eidetik, Eidetik, MyFairPlusAThird, MyFairPlusAThird, Meek, MyFairPlusAThird, MyFairPlusAThird, Meek

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

4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetik, AlCakeSurfer, MyFairPlusAThird, MyFairPlusHarşılaştırılmış

5. fatura, MyFairPlusAThird, fatura, fatura, fatura, fatura, Faturalandırma, Relinquisher, MyFairPlusAThird, Relinquisher, fatura, Reallythecake, fatura, ALittleOffTheTop, ALittleOffTheTop, fatura, fatura

Çalışırken kodlama için tam günlük dosyası burada bulunabilir . Biçim değişikliği için yarı yolda üzgünüm.

Yarışmayı tekrar yürütmeyeceğim, daha fazla giriş yapmak istiyorsanız, bunu yapmaktan memnuniyet duyarsınız , denetleyici bu yarışma için benim github depomda bulunabilir .

Meek, awk

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

Bunu bir kez simülasyonda gördüm.

Sihirbaz, Java

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

720 sayısı büyülü.

_{Bu , kontrol cihazını test etmek içindir ve ciddi bir giriş değildir .}

İnce, Python 2

print 0

Bu bot diyette.

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

Önceden FairBot

FairBot sadece eşit bir kısım istiyor :(

Pastayı tüm katılımcılar arasında eşit olarak bölmek istiyor.

(Diğer botların, onu kastettiklerini, çünkü onların kaba olduğunu bildiklerini düşünüyor.)

(Gerçekten gibi. Yalnız, sadece diğer botların ondan hoşlanmasını istiyor)

(Kötü bir ilişkiden yeni çıktı ve gerçekten pürüzlü bir yamadan geçiyor, bu yüzden ona sırt üstü bir pat verebilir ve onu daha iyi hissetmesini sağlamak için bir gülümseme verebilirseniz, gerçekten çok şey ifade eder.)

EDIT , stdin yerine argv / c 'den girdi almak için programı değiştirdi (adil bot hala üzgün .... Adını sadbot olarak değiştirmek istiyor (ki neden pasta istiyor)

Halver, Yakut

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

Titizlikle, anlaşılmaz derecede adil. Benim için pastanın yarısı, herkes için pastanın yarısı.

Yardımseverlik, Python 2

print -360

Karışıma başka bir pasta ekler!

(Kontrolör bunu 0 kek için bir istek olarak görecek, aslında kekin boyutuna eklenmeyecektir)

Görkemli İmitasyon, 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))

Varyant taklitçi (Bunun yerine oyuncu başına yalnızca bir giriş, biri bu hükümsüz kılar ediyorum ise). Daha önce alınmış en büyük dilimin izini tutar ve daima o dilimi yenecek kadar teklif verir. Ayrıca geri kalanın adil payından daha düşük teklif vermeyecektir. Okunabilir / yazılabilir bir './data' dizininin zaten var olduğunu varsayar; dosyalar zaten orada olabilir veya olmayabilir.

Dieter, Java

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

Çok fazla pasta için teklif vermek istemiyor, bu yüzden küçük fakat garantili rastgele bir dilim seçiyor .

Alevli Testere, 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]);}
    }
}

Elektrikli testere ile pasta kesme yarışması düzenlemeyi hiç denedin mi? Eh, şimdi var. Bu oldukça yıkıcı.

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

Herhangi bir pasta yemeden önce adil bir pay yiyen veya daha az yiyen insanları bekler. Açgözlünün fazladan kek almasını önlemek için, mümkün olduğunca büyük bir bölümünü alır.

Bob Barker, Java

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

Bu muhtemelen daha sonra daha düşünülmüş bir çözümle değiştirilecek, ancak bunun işe yarayıp yaramadığını merak ediyorum. Bu sadece maksimum çabalamaya çalışan ve en yüksek seviyeye ulaşan botları yakalamak ve değiştirilmiş bir Fiyat yapmaktır. Artan tam sayıdaki çıkarmalar ile yükselişe yol açabilir, bu temiz olur.

EDIT: Eskalation başlıyor, FloorBot’a karşı mesaj gönderme

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

Bu botu kontrolörde birkaç kez çalıştırdım, biraz eğitmek için, her turu kazanmak için gereken teklifleri hatırlıyor ve bir kez eğitildikten sonra gerçek dünyaya çıkıyor ve geri kalanıyla oy veriyor.

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

Bu benim ilk PCG gönderim; Umarım bu amaçlandığı gibi çalışır ...

Pastayı severim. Hangi tür olursa olsun. Meslektaşlarım biliyor. Ve botum da öyle. Eğer bütün kek hala oradaysa, en büyük dilimi derhal almayı umarak yarısının hemen altında bir teklif verecek. Aksi takdirde, kalan pastanın yarısı ile kalan pastanın arasında bir şey teklif etmeli, ağırlık fonksiyonu olarak kare bir sinüs kullanmalıdır ( ½ + sin² (fraction gone) / 2). Akıl yürütme, oyunun başlarında daha büyük (ancak kesirsel olarak daha küçük) bir dilim için bir şansın olması ve aynı zamanda oyunun sonunda bir beyefendi olmaya çalışmanın çok az bir noktası olması gerektiğinin nedenidir.

Programlamaya fazla girmediğim için, işaret ettiği herhangi bir hatayı takdir ediyorum. Şimdi biraz pasta yiyelim = D

Şımarık, Yakut

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, kalan pastanın yarısından biraz daha azını kabul etmeye isteklidir; bu, başkalarının edindiğinden veya alması muhtemel olduğundan daha fazla olduğu sürece (gizli sosu temel alarak).

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

İyi bir fincan kahve içermeyen bir kek tam olarak nedir?

CoffeeJunkie, bir dilim pasta yerine kahveyi tercih ediyor, ancak yine de biraz denemek istiyor. Diğer katılımcılara her zaman adil olacak ve son pastanın başına geleni hatırlamaya çalışacaktır. Ancak, aşırı kahve tüketimi anılarını zayıflattı ...

Görkemli Sabotaj, 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))

Bu, bu biçimde görünmeyen diğer dosyaların üzerine yazmanıza izin verildiği anlamına gelir. Bunu kasten yapmamalısın, lütfen sportif ol.

Bu bot rekabeti ortadan kaldırmak için spor yapmaması gerektiğine karar verdi.

Bu, Stately Imitator'ın bir klonudur; bunun haricinde, Stately Imitator'ın ısrar dosyalarını (bot adı ile önceden belirlenmemiş oldukları için) karıştırması dışında yanlış kararlar vermesi ve en son seçilmesi gerekir.

Tüccar, 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])
        }

İnsanların sol oranına göre sol derecelerin evrimini izler ve bu oran düşmeye başladığında makul bir dilim ister, aksi halde kalan tüm pastayı ister. Kullanarak çağrıldı 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 (Bu benim doğum günümdü ve ağladım çünkü istedim), kalan derecelerle kalan insan sayısı arasında bir ilişki olduğunu varsayar. İnşallah işe yarar!

Tüm pitonlarda çalışmalı.

Düzenle:

sys.argvGirdilerde saklamak biraz israf oldu ...

misafir, Python 2

print ord('d')*4

fatura, Python 2

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

Adil bir bahis.

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 çok kötü yaptığı için (ve yarışmada daha da kötüleşmesini bekliyorum) işte ikinci girişim. Ona Surfer adını verdim , çünkü kendisini sörfçü gibi hissettiren çok hoş bir yukarı ve aşağı dalga fonksiyonuna sahip.

Prensip olarak, alınan pastanın kesri cos² (x * pi)olduğu yere göre teklif verir x. Bu sörf dalgası, pastanın yarısından az bir miktardan daha düşük bir oranda başlamasını sağlayan, pastanın yarısı gittiğinde tekliflerini adil bir payın hemen üzerine düşüren ve ardından geri hızlanmasını sağlayan bir ağırlıklandırma işlevi ile değiştirildi. daha sonra tüm pasta için teklif vermek. Kalan pastanın adil bir payından ve% 5'inin (yani tüm pastanın yüzdesi) daha az teklif etmeyecektir.

Kardeşler olsalar bile, AlCakeBot'tan çok daha büyük bir dilim alırsa, ikincisinin tek bir parça bile almadığını unutmayın. Çikolata ya da bisküvi paylaşıyorlardı ama pasta yapmıyorlar!

Aç, 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);
    }
}

Daima kalan pastanın payını almak ister.

Taklitçi, Yakut

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

Amaç, herkesten daha fazla pasta elde etmek, pastalarını en üst düzeye çıkarmak değil. Bu nedenle, bu bot önceki botların daha önce almış olduklarından daha azına razı olmaz. (Bu sürüm bu kontrol için sezgisel tarama kullanıyor, sadece devleti kurtarmamıza izin verdiğimizi fark ettim, bu yüzden muhtemelen daha sonra durumlu bir değişken yayınlayacağım).

Gerçekten pasta, Bash

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

Ve işte gerçek pastanın bir resmi.

Kek Yiyen, 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));
    }
}

Pasta yiyor. Bu konuda.

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

Diğer botumun temel bir çeşidi olan Sabırsız. Bu, ilk başta her şeyi almaya çalışır, ancak gittikçe daha fazla sayıda konuk paylarını aldıkça, mümkün olan en yavaş şekilde alma isteği yavaşlar. Ben buna da dahil değilim; Sadece ne kadar iyi olduğunu görmek istiyorum.

ALittleExtra, sh

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

Sadece biraz daha istiyorum, pasta dolanırken daha az açgözlü olur.

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

Gerçekten π seviyor ve bu pastayı düşünüyor anlamına geliyor olduğunu π.

Üstte Bir Küçük, 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)

“Mükemmel” algoritması pastayı botlar arasında eşit bir şekilde bölmeye çalıştığından, bundan daha az bir şerit alacağız. Daha sonraki turlarda bile genel pastanın tam payını talep eder, ancak kaç kişinin kaldığına bağlı olarak, bu sayıyı yukarı doğru eğriltir.

_{Python'da uzun süredir programlanmadım , bu yüzden kodum bozulursa bana bildirin ...}