Der Kuchenschneidewettbewerb

37

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 .

Blau
quelle
10
Ich bitte um einen Ring, der um den Außenumfang geschnitten ist. Technisch gesehen 0 Grad (der Kuchen hat immerhin noch 360 Grad, wenn ich fertig bin) und ich bekomme die ganze Seitenglasur.
Random832
10
Alles Gute zum Geburtstag :)
TheNumberOne
2
Ergebnisse für eine Runde bei Interesse {u'StatelyImitator': 719, u'Dieter': 4, u'Reallythecake': 0, u'Greedy': 0, u'Meek': 2, u'FlamingChainsaw': 0, u'Slim': 0, u'CharityBot': 0, u'Gentleman': 297, u'ALittleOffTheTop': 256, u'EatThe\u03c0': 0, u'Pig': 0, u'CakeEater': 330, u'BobBarker': 0, u'FloorBot': 5, u'Fatbot5000': 296, u'Moses': 360, u'Magician': 720, u'Hungry': 257, u'Imitator': 354} [u'Magician']. Wenn Ihr Bot eine Punktzahl von 0 hat, stimmt etwas nicht.
Blue
3
Bitte formatieren Sie die Bestenliste leserfreundlicher.
SuperJedi224
2
@ Schlammfisch-Absolventen? Viel eher wie ein Cakeier, oder?
Jan

Antworten:

5

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.

Cabbie407
quelle
Haben Sie einen upvote, Ihr Bot ist verdammt gut tun = O
Jan
Vielen Dank. Nun, es ist kein Zufall. Ich habe den Controller selbst gesteuert und versucht, einen intelligenteren Bot zu schreiben. Aber die meiste Zeit wurde es von den einfachsten Bots geschlagen. Also habe ich eine ziemlich einfache Strategie gewählt, die die meiste Zeit mit einem Kuchen in zufälliger Größe gewonnen hat.
Cabbie407
13

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.

Die Nummer eins
quelle
3
Ich denke, das hat den Wettbewerb tatsächlich so gewonnen, wie er ursprünglich war, mit einer Punktzahl von 720 hier .
PhiNotPi
10

Schlank, Python 2

print 0

Dieser Bot ist auf Diät.

Blau
quelle
10

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)

Liam
quelle
Kannst du es so machen, dass es die Argumente von argv und nicht von stdin nimmt?
Blue
Wie Sie es befohlen haben, ist es auch getan.
Liam
1
Sie können Ihren Namen in sadbot ändern, wenn Sie möchten.
Blue
Außerdem müssen die Klammern in den Codeblock gesetzt werden
Blue
1
Und deshalb ist er ein trauriger Bot.
Liam
9

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.

Histokrat
quelle
8

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

Blau
quelle
7

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.

Histokrat
quelle
Falls Sie es nicht bemerkt haben, habe ich auch mehrere Antworten (aber nur eine ist sinnvoll)
Blue
Es gibt gute und schlechte Nachrichten. Schlecht - es gibt ein bisschen, das deine Konfigurationsdateien ändert. Gut - Ihr Bot macht es besser! 505/3600, es hat die letzte Runde gewonnen, die ich gemacht habe!
Blue
6

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.

DankMemes
quelle
1
Wenn Sie meine Beiträge abgelehnt haben , erklären Sie bitte warum. Sonst kann ich mich nie verbessern!
DankMemes
18
Oh. Ich bin nur davon ausgegangen, dass Sie davon ausgehen können, dass die Ablehnung darauf zurückzuführen ist, dass Sie offensichtlich nur einen xkcd-Verweis für Lachen / Stimmen verwenden.
Geobits
3
Wir haben eine Standardlücke, die die Verwendung von gefälschten Zufallszahlen regelt (auf die in diesem speziellen xkcd ausdrücklich verwiesen wird). Da die Herausforderung keine Zufälligkeit in den Einsendungen erfordert , ist dies nicht unbedingt eine Verletzung der Regelungslücke, aber dennoch. ಠ_ಠ
Alex A.
3
Ich verstehe das, aber nicht wirken dann überrascht , wenn jemand Ihre downvotes „etwas dumm“.
Geobits
2
Stimmen Sie ab, um Leuten ohne Humor entgegenzutreten
Bobby
5

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.

PhiNotPi
quelle
2
Ich finde, dass ich normalerweise das Kettensägengeräusch ausschalten kann, aber es macht wirklich ein Chaos, wenn Sie es zum Schneiden des Kuchens verwenden.
Alex A.
3
Dies ist eine exotische Art, die Kerzen anzuzünden.
TheNumberOne
5

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.

Die Nummer eins
quelle
4

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

Thefistopher
quelle
Ich habe Ihre Beschreibung nach unten verschoben, um den Formatierungsanforderungen der Herausforderung zu entsprechen.
PhiNotPi
@PhiNotPi, woops, diese Anforderung vergessen. Danke, dass du das Problem behoben hast!
Thefistopher
Hah, ich hatte nur den gleichen Gedanken
AdmBorkBork
Nun, der Antwort-Parser betrachtet die erste Zeile und dann den ersten Codeblock. Außerdem müssen Sie args[1]vor dem Subtrahieren in ein int konvertieren .
Blue
@thefistopher müssen Sie noch int-Konvertierung tun
Blue
4

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.

Blau
quelle
Das ist eine clevere Methode. Sie sind jetzt dem Rudel voraus. Ich frage mich, ob dies trotzdem noch verbessert werden könnte ...
ETHproductions
3

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

Jan
quelle
3

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

Histokrat
quelle
3

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

Chiffre
quelle
Können Sie die Sprache in coffeescript von node.js umbenennen?
Blue
Fertig, obwohl Sie node.js benötigen, um zu starten und zu installieren:npm install -g coffee-script; coffee CoffeeJunkie.coffee
Cipher
Bist du sicher, dass das eine Kerze auf deinem Kuchen ist? Es sieht ein bisschen phallischer aus: D
Beta Decay
@BetaDecay ... noch besser? : D
Cipher
@Cipher Das ist gut: D
Beta Decay
2

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.

Riking
quelle
1
"Sie sollten dies nicht absichtlich tun" Zählt das nicht?
Blue
3
Deshalb können wir keine schönen Dinge haben.
Histokrat
@muddyfish Ich habe es im Sinne von RFC2119 genommen. "Es kann unter bestimmten Umständen gültige Gründe geben, wenn das bestimmte Verhalten akzeptabel oder sogar nützlich ist, aber die vollständigen Auswirkungen sollten verstanden werden"
Riking
2

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.

Plannapus
quelle
2

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

Beta-Zerfall
quelle
Es sollte sein degreesleft = int(inputs[2]); peopleleft = int(inputs[4])und es bietet die ganze Zeit 1
Blue
@ Schlammfisch bearbeitet
Beta-Zerfall
2

Gast, Python 2

print ord('d')*4
user193661
quelle
3
Dies ist kein Code Golf, den Sie kennen;)
Blue
2

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.

user193661
quelle
2

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!

Jan
quelle
Wow, ich hatte in den ersten Runden Glück und es ging schnell nach Süden, als andere ihre Bots optimierten = O
Jan
1

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.

CommonGuy
quelle
1

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

Histokrat
quelle
1

Wirklich der Kuchen, Bash

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

Und hier ist ein Bild des echten Kuchens.

Ein Bild des eigentlichen Kuchens

James
quelle
1

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.

SuperJedi224
quelle
1

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.

ETHproductions
quelle
Braucht ein ; in der mathsy line
Blue
@muddyfish Whoops, dachte ich habe es schon mal dort abgelegt. Vielen Dank für den Hinweis!
ETHproductions
Muss auch als int besetzt werden, wie auch das andere
Blue
Dachte es ist schon ...?
ETHproductions
Benötigen Sie int found double?
Blue
1

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

Shaun H
quelle
1

MyFairPlusAThird, sh

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

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 π.

Zahnbürste
quelle
Warum isst es dann Kuchen? : P
TheNumberOne
1
@TheNumberOne Weil es nichts anderes gefüttert wird :(
Zahnbürste
2
@TheNumberOne Jetzt denkt es, dass Kuchen π ist ... Warum hast du das gefragt?
Zahnbürste
Ich musste die maskierten Anführungszeichen aus dem Befehlsskript entfernen und die zweite Zeile des Skripts so umschreiben var totalπ=process.argv[2], πLeft=process.argv[3], totalPeople=process.argv[4], peopleLeft=process.argv[5];, damit dies mit der Steuerung funktioniert. Es erreichte 97 von 3600 im Bereich von 41 Bots.
Cabbie407
1

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

AdmBorkBork
quelle