Es ist mein 17. Geburtstag und du bist zu meiner Party eingeladen!

Und wie immer auf Partys wird es Kuchen geben.

Ein Kuchen ...

Und du brauchst so viel wie möglich.

Da dies eine faire Party ist, wird jeder von uns sagen, wie viel von meinem Kuchen wir wollen, und die Person, die die kleinste Menge gesagt hat, wird es bekommen. Dann können alle anderen den Vorgang wiederholen, bis der Kuchen weg ist.

Herausforderung

• Bei Eingabe über Befehlszeilenargumente in Form von total-degrees degrees-left total-people people-left, Ausgabe in Standardausgabe integer-bid-in-degrees.
• Wenn Ihr Gebot das niedrigste war, erhalten Sie diese Menge Kuchen und sind für die Runde aus.
• Wenn Ihr Gebot nicht am niedrigsten war, kann Ihr Bot auf den verbleibenden Kuchen bieten.
• Für den Fall, dass die niedrigsten Gebote gleich sind, wird die entfernte Person nach dem Zufallsprinzip ausgewählt.
• Am Ende einer Runde gewinnt die Person mit den meisten Kuchen, wenn der Kuchen verschwunden ist oder niemand mehr zum Bieten übrig ist!
• In dem Fall, dass am Ende einer Runde zwei Personen die gleiche Größe haben, wird der Gewinner nach dem Zufallsprinzip aus den Ziehungseinträgen ausgewählt.

Spielweise

• Es wird 17 Runden geben, der Gesamtsieger ist der Teilnehmer mit den meisten Gesamtsiegen.
• Bei einem Unentschieden werden Runden gespielt, bis ein klarer Gewinner feststeht.
• Jeden Tag aktualisiere ich die aktuellen Punktzahlen, damit die Benutzer ihren Eintrag aktualisieren können.

Einreichung

Sie sollten Ihren Eintrag als schreiben

Bot Name, Sprache

Insert
Code
Here

Erklärung / Zufälliges Zeug hier

Wenn Ihr Eintrag nicht auf diese Weise formatiert ist, kann der Controller Ihren Eintrag NICHT ausführen. Wenn ich feststelle, dass dies Ihrem Eintrag zugestoßen ist, werde ich Sie entweder in einem Kommentar benachrichtigen und / oder die Antwort im richtigen Format bearbeiten.

Ihr Eintrag und Dateispeicher

• Ihr Bot kann Dateien im ./data/Verzeichnis und nirgendwo anders speichern .
  • Nicht erforderlich, aber bitte speichern Sie Ihre Dateien als botname*
  • Sie dürfen keine Dateien in diesem Format schreiben, wenn botnamees sich nicht um Ihren Eingabenamen handelt.
  • Dies bedeutet, dass Sie andere Dateien überschreiben dürfen, die nicht in diesem Format angezeigt werden. Sie sollten dies nicht absichtlich tun, bitte seien Sie sportlich.
  • Ihr Bot darf nicht davon ausgehen, dass die benötigten Dateien vorhanden sind, kann jedoch davon ausgehen, dass sie ./data/vorhanden sind.
  • Das liegt daran, dass ich gelegentlich das ./dataVerzeichnis lösche. Dies werde ich tun, wenn die Runden tatsächlich beginnen. (Aber nicht zwischen ihnen)
• Ihr Bot löscht möglicherweise überhaupt keine Dateien
• Ihr Bot darf nur Dateien im ./data/Verzeichnis lesen
  • Das heißt , Sie können bei anderen Einträgen Dateien suchen

Ergebnisse:

Meek hat den Wettbewerb gewonnen! Gut gemacht @ Cabbie407

Und nun zu einigen zufälligen Statistiken:

Eine Liste der Positionen, die jeder Bot eingenommen hat: (Gut gemacht, jeder Bot, der in dieser Liste auftaucht, hat mindestens einmal die Top 5 erreicht!)

1. Meek, Meek, Eidetisch, Eidetisch, Meek, Eidetisch, Eidetisch, Meek, Meek, Meek, Saucy, Meek, Givemethecake, Givemethecake, Givemethecake, Meek, Eidetisch

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

3. Wirklich der Kuchen, AlCakeSurfer, AlCakeSurfer, Meek, AlCakeSurfer, Meek, AlCakeSurfer, AlCakeSurfer, Wirklich der Kuchen, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, Reallythecake

4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, Relinquisher, MyFairPlusathisher, Relin

5. Rechnung, MyFairPlusAThird, Rechnung, Rechnung, Rechnung, Rechnung, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, Rechnung, Reallythecake, Rechnung, ALittleOffTheTop, ALittleOffTheTop, Rechnung, Rechnung

Die vollständige Protokolldatei für den Wettkampf während des Laufens finden Sie hier . Tut mir leid, dass sich das Format zur gleichen Zeit geändert hat.

Ich werde den Wettbewerb nicht mehr durchführen. Wenn Sie weitere Einträge veröffentlichen möchten, können Sie dies gerne tun. Der Controller befindet sich auf meinem Github-Repo für diesen Wettbewerb .

Sanftmütig, awk

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

Ich habe das einmal in einer Simulation gesehen.

Zauberer, Java

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

Die Zahl 720 ist magisch.

_{Dies soll den Controller testen und ist kein ernstzunehmender Eintrag.}

Schlank, Python 2

print 0

Dieser Bot ist auf Diät.

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

Ehemals FairBot

FairBot will nur eine gleiche Portion :(

Er möchte den Kuchen gleichmäßig auf alle Teilnehmer verteilen.

(Er erwartet jedoch, dass die anderen Bots ihn verarschen, weil er weiß, dass sie gemein sind.)

(Wie wirklich. Er ist einsam, er möchte nur, dass die anderen Bots ihn mögen.)

(Er ist gerade aus einer schlechten Beziehung herausgekommen und durchläuft eine wirklich schwierige Phase. Wenn Sie ihm also einfach einen Klaps auf den Rücken geben und ihm ein Lächeln schenken könnten, damit er sich besser fühlt, würde das wirklich viel bedeuten.)

EDIT hat das Programm geändert, um Eingaben von argv / c anstelle von stdin zu übernehmen (fairer Bot ist immer noch traurig ... Er möchte seinen Namen in sadbot ändern (was irgendwie der Grund ist, warum er Kuchen will)

Halver, Rubin

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

Skrupellos, unanfechtbar fair. Die Hälfte des Kuchens für mich, die Hälfte des Kuchens für alle anderen.

CharityBot, Python 2

print -360

Fügt der Mischung einen weiteren Kuchen hinzu!

(Der Controller sieht dies als eine Aufforderung für 0 Kuchen an und erhöht die Größe des Kuchens nicht.)

Stattlicher Nachahmer, 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- Variante (wenn Sie lieber nur einen Eintrag pro Spieler haben möchten, wird dieser ersetzt). Verfolgt genau das größte bereits genommene Slice und bietet immer genug, um dieses Slice zu schlagen. Wird auch nie niedriger bieten als sein gerechter Anteil am Rest. Es wird davon ausgegangen, dass bereits ein lesbares / beschreibbares Verzeichnis './data' vorhanden ist. Die Dateien können entweder bereits vorhanden sein oder nicht.

Dieter, Java

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

Es möchte nicht für zu viel Kuchen bieten, also wählt es eine kleine, aber garantierte zufällige Scheibe.

Flammende Kettensäge, 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]);}
    }
}

Haben Sie jemals versucht, einen Kuchenschneidewettbewerb mit einer Kettensäge durchzuführen? Nun, jetzt hast du. Es ist ziemlich störend.

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

Er wartet auf Leute, die einen fairen Anteil oder weniger essen, bevor er einen Kuchen isst. Damit der Gierige keinen zusätzlichen Kuchen bekommt, nimmt er eine möglichst große Portion.

Bob Barker, Java

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

Dies wird wahrscheinlich später durch eine besser durchdachte Lösung ersetzt, aber ich bin gespannt, ob dies funktionieren wird. Dies dient nur dazu, alle Bots zu fangen, die versuchen, das Maximum zu erreichen, und eine modifizierte Price is Right-Strategie zu verfolgen, um ihre Antwort zu stehlen. Könnte mit zunehmenden Ganzzahl-Subtraktionen zu einer Eskalation führen, das wäre ordentlich.

EDIT: Eskalation beginnt, Gegenbuchung gegen 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()

Ich habe diesen Bot ein paar Mal im Controller ausgeführt, um ihn ein wenig zu trainieren. Er erinnert sich an die Gebote, die für den Sieg jeder Runde erforderlich sind, und nach dem Training geht er in die reale Welt und stimmt mit den anderen ab.

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

Dies ist mein erster PCG-Beitrag. Ich hoffe das klappt wie vorgesehen ...

Ich liebe Kuchen. Egal welche. Meine Kollegen wissen es. Und mein Bot auch. Wenn der gesamte Kuchen noch da ist, bietet er für knapp die Hälfte und hofft, das größte Stück sofort zu bekommen. Wenn nicht, sollte er für etwas zwischen der Hälfte des verbleibenden Kuchens und dem gesamten verbleibenden Kuchen bieten und einen quadratischen Sinus als Gewichtungsfunktion verwenden ( ½ + sin² (fraction gone) / 2). Die Überlegung ist, dass es zu Beginn des Spiels eine Chance für ein insgesamt größeres (aber etwas kleineres) Stück geben sollte und es wenig Sinn macht, im späten Spiel zu versuchen, ein Gentleman zu sein.

Da ich mich nicht sonderlich mit Programmieren beschäftige, würde ich mich über jeden Fehler freuen, der darauf hingewiesen wird. Jetzt lass uns etwas Kuchen essen = D

Frech, 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 ist bereit, etwas weniger als die Hälfte des verbleibenden Kuchens zu akzeptieren, solange es mehr ist, als jemand anderes bekommen hat oder bekommen wird (basierend auf geheimer Soße).

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

Was genau ist ein Kuchen ohne eine gute Tasse Kaffee?

Der CoffeeJunkie zieht Kaffee einem Stück Kuchen vor, möchte aber trotzdem etwas probieren. Er wird anderen Teilnehmern gegenüber immer fair sein und versuchen, sich zu erinnern, was mit dem letzten Kuchen passiert ist. Sein übermäßiger Kaffeekonsum hat jedoch seine Erinnerungen geschwächt ...

Stattliche Sabotage, 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))

Dies bedeutet, dass Sie andere Dateien überschreiben dürfen, die nicht in diesem Format angezeigt werden. Sie sollten dies nicht absichtlich tun, bitte seien Sie sportlich.

Dieser Bot entschied, dass es keinen Sport geben sollte, um den Wettbewerb auszuschalten.

Dies ist ein Klon von Stately Imitator, mit der Ausnahme, dass dieser die Persistenzdateien von Stately Imitator durcheinanderbringt (da ihnen nicht der Bot-Name vorangestellt ist), damit er die falschen Entscheidungen trifft und zuletzt ausgewählt wird.

Händler, 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])
        }

Verfolgt die Entwicklung des Verhältnisses von links nach links und von links nach links. Wenn dieses Verhältnis abnimmt, wird nach einem angemessenen Stück gefragt, andernfalls wird der gesamte verbleibende Kuchen angefordert. Aufgerufen mit 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 (Es war mein Geburtstag und ich habe geweint, weil ich wollte) geht davon aus, dass es einen Zusammenhang zwischen den verbleibenden Abschlüssen und der Anzahl der verbleibenden Personen gibt. Hoffen wir, dass es funktioniert!

Sollte in allen Pythons funktionieren.

Bearbeiten:

Das Speichern sys.argvvon Eingaben war etwas verschwenderisch ...

Gast, Python 2

print ord('d')*4

Rechnung, Python 2

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

Eine faire Wette.

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

Da sich AlCakeBot so schlecht geschlagen hat (und ich erwarte, dass er im Wettbewerb noch schlechter abschneidet), ist hier mein zweiter Beitrag. Ich habe ihn Surfer genannt, weil er eine sehr schöne Auf- und Ab-Wellenfunktion hat, mit der er sich wie ein Surfer fühlt.

Im Prinzip bietet er danach cos² (x * pi), wo xder Bruchteil des Kuchens ist, der genommen worden ist. Diese Surfwelle wurde mit einer Gewichtungsfunktion modifiziert, die ihn dazu veranlasst, mit weniger als einem fairen Anteil weniger als der Hälfte des Kuchens zu beginnen, seine Gebote auf knapp über einen fairen Anteil zu reduzieren, wenn die Hälfte des Kuchens weg ist, und dann wieder schneller zu werden später für den gesamten Kuchen zu bieten. Er wird niemals weniger als einen angemessenen Anteil des verbleibenden Kuchens plus 5% (dh Prozent des gesamten Kuchens) bieten.

Beachten Sie, dass sie vielleicht Brüder sind, aber wenn er ein wesentlich größeres Stück als AlCakeBot bekommt, bekommt dieser nicht einmal eine einzige Krume davon. Sie würden Schokolade oder Kekse teilen, aber keinen Kuchen!

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

Will immer seinen gerechten Anteil am restlichen Kuchen.

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

Das Ziel ist es, mehr Kuchen als jeder andere zu bekommen und nicht Ihren Kuchen zu maximieren. Daher wird sich dieser Bot nicht mit weniger zufrieden geben als die vorherigen Bots. (Diese Version verwendet Heuristiken für diese Prüfung. Ich habe gerade bemerkt, dass wir tatsächlich den Status speichern dürfen, daher werde ich wahrscheinlich später eine statusbehaftete Variante veröffentlichen.)

Wirklich der Kuchen, Bash

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

Und hier ist ein Bild des echten Kuchens.

Kuchen-Esser, 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));
    }
}

Es isst Kuchen. Das ist alles.

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

Eine grundlegende Variante meines anderen Bots, Ungeduldig. Dieser versucht zunächst, das Ganze zu verstehen, doch je mehr Gäste ihren Anteil daran haben, desto geringer wird der Wunsch, das Möglichste zu erreichen. Ich bin nicht zu sehr mit diesem beschäftigt. Ich will nur sehen, wie gut es funktioniert.

ALittleExtra, sh

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

Ich will nur ein bisschen mehr und werde weniger gierig, wenn der Kuchen nachlässt

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

Mag π wirklich und denkt an diesen Kuchen meint ist π.

Etwas abseits der Spitze, 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)

Da der "perfekte" Algorithmus versucht, den Kuchen gleichmäßig auf die Bots aufzuteilen, werden wir nur ein Stück weniger nehmen. Fordert seinen vollen fairen Anteil am Gesamtkuchen, auch in den folgenden Runden, verzerrt diese Zahl jedoch nach oben, da sie davon abhängt, wie viele Leute übrig sind.

_{Ich habe nicht in Python in einer programmierten langen Zeit, so lassen Sie mich wissen , wenn mein Code gebrochen ist ...}