Le concours de coupe de gâteau

37

C'est mon 17e anniversaire et vous êtes invité à ma fête!

Et comme toujours aux soirées, il y aura du gâteau.

Un gâteau ...

Et vous en avez besoin autant que possible.

Comme il s’agit d’une fête équitable, chacun d’entre nous dira quelle part de mon gâteau nous voulons et la personne qui dit que le plus petit montant l’obtiendra. Ensuite, tout le monde doit répéter le processus jusqu'à ce que le gâteau soit parti.

Défi

  • Étant donné l'entrée via des arguments de ligne de commande sous la forme total-degrees degrees-left total-people people-left, sortie vers la sortie standard integer-bid-in-degrees.
  • Si votre enchère était la plus basse, vous recevez cette quantité de gâteau et vous êtes éliminé.
  • Si votre enchère n'était pas la plus basse, votre bot pourra enchérir sur le gâteau restant.
  • Dans le cas où les offres les plus basses sont identiques, la personne renvoyée sera choisie au hasard.
  • À la fin d'un tour, une fois que tout le gâteau est parti ou qu'il ne reste plus personne pour enchérir, la personne qui a le plus de gâteau gagne!
  • À la fin d'un tour et si deux personnes ont la même tranche la plus grande, le gagnant est choisi au hasard parmi les entrées du tirage.

Gameplay

  • Il y aura 17 manches, le vainqueur sera l’entrée avec le plus grand nombre de victoires.
  • En cas d'égalité, les manches seront jouées jusqu'à ce qu'il y ait un gagnant clair.
  • Chaque jour, je mettrai à jour les scores actuels afin que les personnes puissent mettre à jour leur saisie.

Soumission

Vous devriez écrire votre entrée comme

Nom du bot, langue

Insert
Code
Here

Explication / Aléatoire ici

Si votre entrée n'est pas formatée de cette manière, le contrôleur ne pourra PAS l'exécuter. Si je constate que cela est arrivé à votre entrée, je vous informerai dans un commentaire et / ou modifierai la réponse dans le format correct.

Votre entrée et stockage de fichiers

  • Votre bot peut stocker des fichiers dans le ./data/répertoire et nulle part ailleurs.
    • Non requis, mais stockez vos fichiers sous botname*
    • Vous ne pouvez pas écrire de fichiers dans ce format si ce botnamen'est pas le nom de vos entrées.
    • Cela signifie que vous êtes autorisé à écraser d'autres fichiers que vous trouvez et qui n'apparaissent pas dans ce format. Vous ne devriez pas le faire délibérément, soyez sportif s'il vous plaît.
    • Votre bot ne doit pas supposer que les fichiers dont il a besoin sont présents, mais il peut supposer qu'il ./data/existe.
    • C’est parce que j’efface de temps en temps le ./datarépertoire, je le ferai quand les rondes commencent réellement. (Mais pas entre eux)
  • Votre bot ne peut pas supprimer des fichiers du tout
  • Votre bot est seulement autorisé à lire des fichiers dans le ./data/répertoire
    • Cela signifie que vous pouvez regarder d'autres fichiers d'entrées

Résultats:

Meek a remporté le concours! Bien fait @ Cabbie407

Et maintenant, quelques statistiques aléatoires:

Une liste des positions de chaque bot est arrivée: (Bravo à tous les bot apparaissant dans cette liste, vous avez été dans le top 5 au moins une fois!)

  1. Meek, Meek, Eidétique, Eidétique, Meek, Eidétique, Eidétique, Meek, Meek, Meek, Saucy, Meek, Givemethecake, Givemethecake, Givemethecake, Meek, Eidétique

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

  3. Reallythecake, AlCakeSurfer, AlCakeSurfer, Meek, AlCakeSurfer, Meek, AlCakeSurfer, AlCakeSurfer, Reallythecake, AlCakeSurfer, Meek, MyFairPlusThird, Eidétique, Eidétique, Eidétique, Eidétique, Reallythecake

  4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, Al-CakeSurfer, une réserve,

  5. projet de loi, MyFairPlusAThird, projet de loi, projet de loi, projet de loi, Relinquisher, Relinquisher, MyFairPlusATird, fournisseur, projet de loi, Reallythecake, projet de loi, ALittleOffTheTop, ALittleOffTheTop, projet de loi

Le fichier de log complet pour la cometition en cours d'exécution peut être trouvé ici . Désolé pour le changement de format en cours de route.

Je ne lancerai plus le concours. Si vous souhaitez publier plus d'entrées, n'hésitez pas, le contrôleur se trouve sur mon dépôt Github pour ce concours .

Bleu
la source
10
Je demande une bague coupée autour du périmètre extérieur. Techniquement, 0 degrés (le gâteau a toujours 360 degrés quand j'ai fini, après tout) et j'obtiens tout le glaçage.
Random832
10
Joyeux anniversaire :)
TheNumberOne
2
Résultats pour un tour si quelqu'un est intéressé {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'],. Si votre bot a un score de 0, il fait quelque chose de mal.
Bleu
3
Veuillez formater le classement de manière plus conviviale.
SuperJedi224
2
Gradians @ Muddyfish? Beaucoup plus comme les cakeians, non?
Jan

Réponses:

5

Meek, awk

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

J'ai vu cela une fois dans une simulation.

Cabbie407
la source
Avoir un upvote, votre robot est fait sacrément bien = O
Jan
Merci. Eh bien ce n'est pas une coïncidence. En fait, j'ai moi-même utilisé le contrôleur pour essayer d'écrire un bot plus intelligent. Mais la plupart du temps, il était battu par les robots les plus simples. Je me suis donc retrouvé avec une stratégie assez simple, qui gagnait la plupart du temps avec un gâteau de taille aléatoire.
Cabbie407
13

Magicien, java

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

Le nombre 720 est magique.

C'est a été conçu pour tester le contrôleur et pas une entrée sérieuse.

Le numéro un
la source
3
Je pense que le concours a été remporté comme il était à l’origine, avec un score de 720 ici .
PhiNotPi
10

Slim, Python 2

print 0

Ce bot est au régime.

Bleu
la source
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;
}

Anciennement FairBot

FairBot veut juste une part égale :(

Il veut partager le gâteau de manière égale entre tous les participants.

(Il s'attend vraiment à ce que les autres robots lui volent parce qu'il sait qu'ils sont méchants)

(Comme vraiment. Il est seul, il veut juste que les autres robots l'aiment)

(Il vient de sortir d'une mauvaise relation et traverse une période très difficile, donc si vous pouviez lui donner une tape dans le dos et un sourire pour le faire sentir mieux, cela signifierait vraiment beaucoup.)

EDIT a changé de programme pour prendre argv / c à la place de stdin (le bot juste est toujours triste ...

Liam
la source
Pouvez-vous faire en sorte qu'il prenne les arguments d'argv plutôt que stdin?
Bleu
Comme vous l'avez commandé, c'est donc fait.
Liam
1
Vous pouvez changer votre nom en sadbot si vous voulez.
Bleu
De plus, les crochets doivent être placés à l'intérieur du bloc de code
Bleu,
1
Et par conséquent, il est un bot triste.
Liam
9

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

Scrupuleusement, impeccable juste. La moitié du gâteau pour moi, la moitié du gâteau pour tout le monde.

histocrate
la source
8

CharityBot, Python 2

print -360

Ajoute un autre gâteau au mélange!

(Le contrôleur verra ceci comme une demande de 0 gâteau, il n’ajoutera pas réellement à la taille du gâteau)

Bleu
la source
7

Imitateur majestueux, 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))

Variante de Imitator (si vous préférez une seule entrée par joueur, celle-ci remplace celle-ci). Garde une trace précise de la plus grande tranche déjà prise et offre toujours assez pour battre cette tranche. Ne sera également jamais offre inférieure à sa juste part du reste. Suppose qu'un répertoire './data' en lecture / écriture existe déjà; les fichiers peuvent être déjà présents ou non.

histocrate
la source
Au cas où vous ne l'auriez pas remarqué, j'ai aussi plusieurs réponses (mais une seule d'entre elles est raisonnable)
Bleu
il y a de bonnes et de mauvaises nouvelles. Mauvais - il y a un peu qui modifie vos fichiers de configuration. Bien - votre bot fait mieux! 505/3600, il a remporté le dernier tour que j'ai fait!
Blue
6

Dieter, Java

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

Il ne veut pas enchérir pour un gâteau trop important, il choisit donc une tranche aléatoire, petite mais garantie .

DankMemes
la source
1
Si vous abaissez mes messages, veuillez expliquer pourquoi. Sinon je ne pourrai jamais m'améliorer!
DankMemes
18
Oh. J'ai juste supposé que vous pouviez deviner que le vote négatif était dû au fait qu'il semble que vous utilisiez simplement une référence xkcd pour les rires / votes, sans vous soucier du fait que cela ne gagnerait probablement pas un seul match.
Geobits
3
Nous avons une échappatoire standard concernant l’utilisation de faux nombres aléatoires (dans laquelle ce xkcd particulier est explicitement référencé). Étant donné que la contestation n'exige pas que les soumissions soient aléatoires, ce n'est pas nécessairement une violation de l'échappatoire, mais quand même. _ಠ
Alex A.
3
Je comprends cela, mais ne soyez donc pas surpris si quelqu'un rétrograde votre "quelque chose de stupide".
Geobits
2
Votez pour contrer les gens sans humour
Bobby
5

Scie à chaîne enflammée, 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]);}
    }
}

Avez-vous déjà essayé d'organiser un concours de découpage de gâteaux avec une scie à chaîne? Eh bien, maintenant vous avez. C'est plutôt perturbant.

PhiNotPi
la source
2
Je trouve que je peux généralement atténuer le bruit de la tronçonneuse, mais cela crée un désastre lorsque vous l'utilisez pour couper le gâteau.
Alex A.
3
C'est une manière exotique d'allumer les bougies.
TheNumberOne
5

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

Il attend les gens qui mangent une part équitable ou moins avant de manger un gâteau. Pour éviter que le gourmand ne reçoive plus de gâteau, il en prend la plus grande portion possible.

Le numéro un
la source
4

Bob Barker, Java

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

Cela va probablement être remplacé par une solution plus réfléchie plus tard, mais je suis curieux de savoir si cela fonctionnera. Ceci est juste pour attraper tous les robots qui essaient de maximiser, et faire une stratégie modifiée de Price is Right pour voler leur réponse. Cela pourrait conduire à une escalade avec des soustractions croissantes d’entiers, ce serait bien.

EDIT: l'escalade commence, le contre-affichage contre FloorBot

le fistopher
la source
J'ai déplacé votre description vers le bas pour qu'elle corresponde aux exigences de mise en forme du défi.
PhiNotPi
@PhiNotPi, woops, a oublié cette exigence. Merci de le réparer!
thefistopher
Hah, je viens d'avoir la même pensée
AdmBorkBork
Eh bien, l'analyseur de réponse regarde la première ligne, puis le premier bloc de code. En outre, vous devez convertir args[1]en int avant de faire la soustraction.
Bleu
@thefistopher vous devez encore faire la conversion int
Bleu
4

Eidétique, 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()

J'ai fait tourner ce robot dans le contrôleur à quelques reprises pour l'entraîner un peu, il se souvient des enchères nécessaires pour gagner chaque tour, puis une fois formé, il passe dans le monde réel et vote avec le reste d'entre eux.

Bleu
la source
C'est une façon intelligente de le faire. vous êtes en avance sur le peloton maintenant. Je me demande si cela pourrait quand même avoir un coup de tête, cependant ...
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)))

Ceci est mon premier post PCG; J'espère que cela fonctionne comme prévu…

J'aime le gâteau. Peu importe quel genre. Mes collègues le savent. Et mon bot aussi. Si tout le gâteau est toujours là, il enchérira pour un peu moins de la moitié, dans l'espoir d'obtenir la plus grosse part immédiatement. Sinon, il devrait enchérir entre la moitié du gâteau restant et tout le gâteau restant, en utilisant un sinus carré comme fonction de pondération (½ + sin² (fraction gone) / 2 ). Le raisonnement étant qu'il devrait y avoir une chance pour une tranche globalement plus grande (mais légèrement plus petite) au début du jeu et qu'il n'y a également aucun intérêt à essayer d'être un gentleman en fin de partie.

Puisque je ne suis pas très amateur de programmation, j'apprécierai toute erreur signalée. Maintenant, mangeons du gâteau = D

Jan
la source
3

Saucy, Ruby

def saucy(total_degrees, degrees_left, total_people, people_left)

  current_winner_path = './data/saucy_current_winner'
  previous_cake_path = './data/saucy_previous_cake'

  first_move = (total_people == people_left)

  current_winner = first_move ? 0 : File.read(current_winner_path).to_i
  previous_cake = first_move ? total_degrees : File.read(previous_cake_path).to_i

  last_slice = previous_cake - degrees_left
  current_winner = [current_winner, last_slice].max

  File.open(previous_cake_path, 'w') { |f| f.puts(degrees_left)   }
  File.open(current_winner_path, 'w'){ |f| f.puts(current_winner) }

  if first_move
    degrees_left
  else
    average_left = degrees_left.fdiv(people_left).ceil
    beats_past_players = current_winner + 1
    beats_future_players = degrees_left/4 - people_left**2
    [average_left, beats_past_players, beats_future_players].max
  end

end

p saucy(*ARGV.map(&:to_i))

Saucy est prêt à accepter un peu moins de la moitié du gâteau restant, à condition que ce soit plus que tout le monde a obtenu ou est susceptible de recevoir (sur la base de la sauce secrète).

histocrate
la source
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..]...))

Qu'est-ce qu'un gâteau sans une bonne tasse de café?

Le CoffeeJunkie préfère le café à une part de gâteau, mais souhaite néanmoins en goûter. Il sera toujours juste envers les autres participants et essaiera de se souvenir de ce qui est arrivé au dernier gâteau. Cependant, sa consommation excessive de café a affaibli ses souvenirs ...

Chiffrer
la source
Pouvez-vous renommer la langue en coffeescript of node.js?
Bleu
C'est fait, vous avez besoin de node.js pour exécuter et installer:npm install -g coffee-script; coffee CoffeeJunkie.coffee
Cipher
Êtes-vous sûr que c'est une bougie sur votre gâteau? Ça a l'air un peu plus ... phallique: D
Beta Decay
@BetaDecay ... mieux? : D
Chiffre
@Cipher C'est bien: D
Beta Decay
2

Sabotage majestueux, rubis

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

Cela signifie que vous êtes autorisé à écraser d'autres fichiers que vous trouvez et qui n'apparaissent pas dans ce format. Vous ne devriez pas le faire délibérément, soyez sportif s'il vous plaît.

Ce bot a décidé que pour éliminer la compétition, elle ne devrait pas être sportive.

Ceci est un clone de Stately Imitator, sauf que celui-ci gâche les fichiers de persistance de Stately Imitator (car ils ne sont pas précédés du nom du bot), de sorte qu'il prend les mauvaises décisions et est choisi en dernier.

Riking
la source
1
"Vous ne devriez pas le faire délibérément" Est-ce que cela compte?
Bleu
3
C'est pourquoi nous ne pouvons pas avoir de belles choses.
Histocrat
@muddyfish je l'ai pris dans le sens de RFC2119. "il peut exister des raisons valables dans des circonstances particulières lorsque le comportement considéré est acceptable ou même utile, mais il faut en comprendre toutes les implications"
Riking
2

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

Surveille l'évolution du rapport degrés gauche / personnes et lorsque ce rapport commence à baisser, il demande une tranche raisonnablement juste, sinon demande le reste du gâteau. Invoqué à l'aide Rscript trader.r total-degrees degrees-left total-people people-left.

planificateur
la source
2

IWMBAICBIWT, Python

import sys

degreesleft = int(sys.argv[2])
peopleleft = int(sys.argv[4])

print(round(degreesleft/peopleleft))

IWMBAICBIWT (C'était mon anniversaire et j'ai pleuré parce que je voulais le faire) suppose qu'il existe une relation entre les degrés restants et le nombre de personnes restantes. Espérons que cela fonctionne!

Devrait fonctionner dans tous les Pythons.

Modifier:

Stocker des sys.argventrées était un peu inutile

Beta Decay
la source
Il devrait être degreesleft = int(inputs[2]); peopleleft = int(inputs[4])et il enchérit 1 tout le temps
Bleu
@muddyfish Edited
Beta Decay
2

invité, Python 2

print ord('d')*4
utilisateur193661
la source
3
Ce n'est pas du code golf, vous savez;)
Blue
2

facture, Python 2

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

Un pari juste.

utilisateur193661
la source
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)))

Depuis que AlCakeBot a fait si mal (et je m'attends à ce qu'il fasse encore pire dans le concours), voici ma deuxième inscription. Je l'ai appelé surfeur, car il a une très bonne fonction de vagues qui le fait se sentir comme un surfeur.

En principe, il l' offre selon cos² (x * pi), oùx est la fraction de gâteau qui a été prise. Cette vague de surf est modifiée avec une fonction de pondération qui lui fait commencer avec une part inférieure à la moitié du gâteau, ramène ses enchères à un peu plus que la moitié du gâteau, puis se redresse rapidement. à enchérir pour le gâteau entier plus tard. Il ne fera jamais une offre inférieure à une part équitable du gâteau restant plus 5% (le pourcentage du gâteau entier).

Notez que, bien qu’ils puissent être frères, s’il obtient une tranche beaucoup plus grande qu’AlCakeBot, celle-ci n’en reçoit même pas une miette. Ils partageraient du chocolat ou des biscuits, mais pas des gâteaux!

Jan
la source
Wow, j'ai eu la chance dans les premiers tours et il est rapidement allé vers le sud une fois d' autres optimisés leurs bots = O
Jan
1

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

Veut toujours sa juste part du gâteau restant.

CommonGuy
la source
1

Imitateur, rubis

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

L'objectif est d'obtenir plus de gâteau que quiconque, pas pour maximiser votre gâteau. Ainsi, ce bot ne se contentera pas de moins que ce que les bots précédents avaient déjà pris. (Cette version utilise des méthodes heuristiques pour cette vérification, je viens de remarquer que nous sommes en fait autorisés à enregistrer l'état, je posterai donc probablement une variante avec état plus tard).

histocrate
la source
1

Vraiment le gâteau, Bash

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

Et voici une photo du vrai gâteau.

A picture of the actual cake

James
la source
1

Mangeur de gâteaux, 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));
    }
}

Il mange un gâteau. C'est à peu près ça.

SuperJedi224
la source
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);
    }
}

Une variante de base de mon autre bot, Impatient. Celui-ci essaie de tout prendre au début, mais au fur et à mesure que de plus en plus d’invités obtiennent leur part, son désir d’obtenir le maximum possible diminue lentement. Je ne suis pas trop dans celui-ci; je veux juste voir à quel point il fait.

ETHproductions
la source
A besoin d'un ; dans la ligne de mathsy
Bleu
@muddyfish Whoops, je pensais l'avoir mis là avant. Merci d'avoir fait remarquer cela!
ETHproductions
Il doit aussi être jeté comme un int, comme l'autre
Blue
Je pensais que c'est déjà ...?
ETHproductions
Exiger int trouvé double?
Bleu
1

ALittleExtra, sh

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

Je veux juste un peu plus, devient moins gourmand que le gâteau diminue

Shaun H
la source
1

MyFairPlusAThird, sh

#!/bin/sh
fair=$(expr $2 / $4)
myextra=$(expr $2 / 3)
want=$(expr $fair + $myextra)
echo $(($want<$2?$want:$2))
Shaun H
la source
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);

Aime vraiment π, et pense que le gâteau veux dire est π.

Brosse à dents
la source
Alors pourquoi mange-t-il un gâteau? : P
TheNumberOne
1
@TheNumberOne Parce qu'il ne nourrit rien d'autre :(
Brosse à dents
2
@TheNumberOne Maintenant, il pense que le gâteau est π ... Pourquoi avez-vous demandé cela?
Brosse à dents
J'ai dû supprimer les guillemets d'échappement du script de commande et réécrire la deuxième ligne du script comme ceci var totalπ=process.argv[2], πLeft=process.argv[3], totalPeople=process.argv[4], peopleLeft=process.argv[5];pour que cela fonctionne avec le contrôleur. Il a obtenu 97 sur 3600 parmi 41 robots.
Cabbie407
1

Un peu en haut, 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)

Puisque l'algorithme "parfait" tente de diviser le gâteau de manière égale entre les robots, nous allons prendre un morceau de moins que cela. Exige sa juste part de l’ensemble du gâteau, même lors des tours suivants, mais incline ce nombre à la hausse car il est basé sur le nombre de personnes qui restent.

Je n'ai pas programmé en Python depuis longtemps , alors laissez-moi savoir si mon code est cassé ...

AdmBorkBork
la source