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 .

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.

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

Slim, Python 2

print 0

Ce bot est au régime.

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

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.

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)

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.

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 .

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.

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.

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

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.

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

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

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

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.

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.

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

invité, Python 2

print ord('d')*4

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.

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!

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.

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

Vraiment le gâteau, Bash

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

Et voici une photo du vrai gâteau.

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.

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.

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

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

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

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