내 17 번째 생일이며 파티에 초대되었습니다!

그리고 항상 파티 에서처럼 케이크가 있습니다.

케이크 하나 ...

그리고 가능한 한 많이 필요합니다.

이것이 공정한 파티이기 때문에 우리 각자는 우리가 원하는 케이크의 양과 가장 적은 양을 말한 사람이 그것을 얻을 것이라고 말할 것입니다. 그런 다음 다른 사람들은 케이크가 사라질 때까지 과정을 반복해야합니다.

도전

• 명령 줄 인수를 통한 입력의 형식은 total-degrees degrees-left total-people people-left표준 출력으로 출력 integer-bid-in-degrees됩니다.
• 입찰가가 가장 낮 으면 해당 금액의 케이크를 받고 라운드에 나갑니다.
• 입찰가가 가장 낮지 않은 경우 봇은 나머지 케이크에 입찰합니다.
• 최저 입찰가가 동일한 경우 제거 된 사람이 임의로 선택됩니다.
• 라운드가 끝나면 모든 케이크가 사라지거나 입찰 할 사람이 없으면 케이크가 가장 많은 사람이 승리합니다!
• 라운드가 끝나고 두 사람이 같은 크기의 가장 큰 슬라이스를 가진 경우, 승자는 추첨 작에서 무작위로 선택됩니다.

게임 플레이

• 17 라운드가있을 것이며, 전체 승자가 가장 많은 승을 가진 항목이 될 것입니다.
• 추첨의 경우, 승자가 분명해질 때까지 라운드가 진행됩니다.
• 매일 사람들이 자신의 항목을 업그레이드 할 수 있도록 현재 점수를 업데이트합니다.

제출

다음과 같이 입력해야합니다.

봇 이름, 언어

Insert
Code
Here

설명 / 임의의 내용은 여기에

입력 형식이이 형식으로되어 있지 않으면 컨트롤러가 입력을 실행할 수 없습니다. 입력 한 내용이 발견되면 의견을 보내거나 올바른 형식으로 답변을 편집하겠습니다.

엔트리 및 ​​파일 저장

• 봇은 ./data/디렉토리와 다른 곳에 파일을 저장할 수 있습니다 .
  • 필요하지 않지만 파일을 botname*
  • botname항목 이름이 아닌 경우이 형식으로 파일을 쓸 수 없습니다 .
  • 즉,이 형식으로 표시되지 않는 다른 파일을 덮어 쓸 수 있습니다. 당신은 이것을 의도적으로하지 말아야합니다.
  • 봇은 필요한 파일이 존재한다고 가정해서는 안되지만 ./data/존재 한다고 가정 할 수 있습니다.
  • 이것은 내가 가끔 와이프 때문이다 ./data디렉토리를, 내가 할 라운드가 실제로 시작할 때이 작업을 수행. (그러나 그들 사이는 아닙니다)
• 봇이 파일을 전혀 삭제하지 못할 수 있습니다
• 봇은 ./data/디렉토리 에있는 파일 만 읽을 수 있습니다
  • 이것은 다른 항목 파일을 볼 수 있음을 의미 합니다

결과 :

Meek이 컨테스트에서 우승했습니다! 잘 했어요 @ Cabbie407

그리고 이제 임의의 통계에 대해 :

각 봇이 들어온 위치 목록 : (이 목록에 나오는 봇은 모두 한 번 이상 상위 5 위에 올랐습니다!)

1. 온유, 온유, Eidetic, Eidetic, 온유, Eidetic, Eidetic, 온유, 온유, 온유, 소스, 온유, Givemethecake, Givemethecake, Givemethecake, 온유, Eidetic

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

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

4. AlCakeSurfer, Reallythecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, Relinquisher, 양도자, 청구서, 청구서, Relinquisher

5. 청구서, MyFairPlusAThird, 청구서, 청구서, 청구서, 청구서, 양도자, 양도자, MyFairPlusAThird, 양도자, 청구서, Reallythecake, 청구서, ALittleOffTheTop, ALittleOffTheTop, 청구서, 청구서

실행 중에 혜성에 대한 전체 로그 파일은 여기 에서 찾을 수 있습니다 . 형식 변경 도중에 죄송합니다.

컨테스트를 다시 진행하지 않을 것입니다. 더 많은 출품작을 게시하려면 환영합니다 . 컨테스트의 내 github 저장소 에서 컨트롤러를 찾을 수 있습니다 .

온유, awk

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

나는 이것을 시뮬레이션에서 한 번 보았다.

마술사, 자바

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

720은 마법입니다.

_{이것은 되는 컨트롤러를 테스트하는 의미이며 한 하지 심각한 항목.}

슬림, Python 2

print 0

이 봇은 다이어트 중입니다.

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

이전 FairBot

FairBot은 동일한 부분을 원합니다.

그는 모든 참가자들 사이에 케이크를 고르게 나누기를 원합니다.

(그는 다른 봇이 자신을 의미한다고 생각하기 때문에 그를 찢을 것으로 기대합니다)

(정말처럼. 그는 외롭고, 다른 봇이 그를 좋아하기를 원합니다)

(그는 단지 나쁜 관계를 벗어 났고 정말로 거친 패치를 겪고 있습니다. 따라서 등을 가볍게 두드리고 기분을 좋게하기 위해 미소를 지을 수 있다면 정말 많은 것을 의미합니다.)

EDIT 는 stdin 대신 argv / c에서 입력을 받도록 프로그램을 변경했습니다. (페어 봇은 여전히 ​​슬프습니다 .... 그의 이름을 sadbot으로 바꾸고 싶습니다 (케이크를 원하는 이유))

할버, 루비

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

꼼꼼하고 공정하게 공평합니다. 나를위한 케이크의 절반, 다른 사람들을위한 케이크의 절반.

CharityBot, Python 2

print -360

믹스에 다른 케이크를 추가합니다!

(컨트롤러는 이것을 0 케이크에 대한 요청으로 보지만 실제로 케이크 크기에 추가하지는 않습니다)

당당한 모방 자, 루비

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

의 변형 테이터 (당신은 오히려 선수 당 하나 개의 항목 중 하나가이 대체를 원하는 경우). 이미 촬영 한 가장 큰 슬라이스를 정확하게 추적하고 항상 해당 슬라이스를 이길만큼 충분히 입찰합니다. 또한 나머지의 공정한 비율보다 낮게 입찰하지 않습니다. 읽기 / 쓰기 가능한 './data'디렉토리가 이미 있다고 가정합니다. 파일이 이미 있거나 없을 수 있습니다.

디 이터, 자바

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

너무 많은 케이크에 입찰하기를 원하지 않으므로 작지만 보장 된 임의 슬라이스를 선택합니다 .

불타는 전기 톱, 자바

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

전기 톱으로 케이크 자르기 대회를 개최 한 적이 있습니까? 글쎄, 지금 당신은 가지고 있습니다. 오히려 파괴적입니다.

신사, 자바

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

그는 케이크를 먹기 전에 공정한 몫 이하를 먹는 사람들을 기다립니다. 욕심 많은 케이크를 얻는 것을 방지하기 위해, 그는 가능한 한 큰 부분을 차지합니다.

밥 바커, 자바

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

이것은 아마도 나중에 더 신중한 해결책으로 대체 될 것이지만 이것이 효과가 있는지 궁금합니다. 이것은 최대로 시도하고 이동하는 모든 봇을 잡고 수정 된 Price is Right 전략을 수행하여 답변을 도용하는 것입니다. 정수 뺄셈이 증가함에 따라 에스컬레이션이 발생할 수 있습니다.

편집 : 이관 시작, FloorBot에 대한 카운터 게시

이데 틱, 파이썬 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()

나는 컨트롤러 에서이 봇을 몇 번 훈련하여 조금 훈련 시켰으며, 각 라운드에서 이기기 위해 필요한 입찰을 기억하고 일단 훈련되면 실제 세계로 나가 나머지 사람들과 투표합니다.

AlCakeBot, 파이썬

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

이것은 나의 첫 PCG 게시물입니다. 나는 이것이 의도 한대로 작동하기를 바랍니다 ...

케이크 좋아해. 어떤 종류의. 동료들은 알고 있습니다. 내 봇도 마찬가지입니다. 전체 케이크가 여전히 존재한다면, 그는 가장 큰 슬라이스를 즉시 얻기를 희망하면서 절반 이하에 입찰 할 것입니다. 그렇지 않은 경우, 나머지 사인의 절반과 나머지 케이크 사이의 값에 대해 제곱 사인을 가중치 함수 ( ½ + sin² (fraction gone) / 2) 로 사용하여 입찰해야합니다 . 게임 초반에 전반적으로 더 큰 (그러나 부분적으로 더 작은) 슬라이스가있을 가능성이 있고, 게임 후반에 신사가 되려는 시도도 거의 없다는 추론.

프로그래밍에별로 익숙하지 않기 때문에 지적한 오류가 있으면 감사하겠습니다. 이제 케이크를 먹자 = D

소스, 루비

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는 남은 케이크의 절반보다 약간 적은 양을 받아 들일 것입니다.

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

커피 한 잔이없는 케이크는 정확히 무엇입니까?

CoffeeJunkie는 케이크 한 조각보다 커피를 선호하지만 그럼에도 불구하고 시도하고 싶어합니다. 그는 항상 다른 참가자들에게 공평하고 마지막 케이크에서 일어난 일을 기억하려고 노력할 것입니다. 그러나 그의 과도한 커피 소비는 그의 기억을 약화 시켰습니다 ...

당당한 사보타주, 루비

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

즉,이 형식으로 표시되지 않는 다른 파일을 덮어 쓸 수 있습니다. 당신은 이것을 의도적으로하지 말아야합니다.

이 봇은 경쟁을 제거하기 위해 스포츠를해서는 안된다고 결정했습니다.

이것은 Stately Imitator의 복제본입니다. 단, 봇 이름이 접두어로 붙지 않은 Stately Imitator의 지속성 파일이 엉망이되어 잘못된 결정을 내리고 마지막에 선택됩니다.

상인, 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])
        }

남은 비율과 남은 비율의 변화를 추적하고 그 비율이 낮아지기 시작하면 합리적으로 공정한 조각을 요구하고 그렇지 않으면 나머지 케이크 전체를 요구합니다. 를 사용하여 호출했습니다 Rscript trader.r total-degrees degrees-left total-people people-left.

IWMBAICBIWT, 파이썬

import sys

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

print(round(degreesleft/peopleleft))

IWMBAICBIWT (생일이었고 원했기 때문에 울었습니다)는 남은 정도와 남은 사람의 수 사이에 관계가 있다고 가정합니다. 그것이 효과가 있기를 바랍니다!

모든 파이썬에서 작동합니다.

편집하다:

sys.argv입력을 저장 하는 것은 약간 낭비였습니다 ...

손님, 파이썬 2

print ord('d')*4

빌, 파이썬 2

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

요정 내기.

AlCakeSurfer, 파이썬

import sys, math

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])

fraction_left = (degrees_left + 0.0)/ total_degrees
fraction_gone = 1.0 - fraction_left
fair_share = fraction_left/people_left
modified_fair_share = fair_share + 0.05

weighting = 0.5 * fraction_gone + 0.5 - modified_fair_share
surfing = (math.cos(fraction_gone * math.pi))**2

print(int(math.floor((weighting * surfing + modified_fair_share)* total_degrees)))

AlCakeBot이 너무 나쁘게 (그리고 대회에서 더 나빠질 것으로 기대합니다) 여기에 두 번째 항목이 있습니다. 나는 그를 서퍼 라고 불렀습니다. 그는 아주 멋진 위아래 웨이브 기능을 가지고 있기 때문에 서퍼처럼 느끼게합니다.

에 원칙적으로, 그는 따라 입찰 cos² (x * pi)곳, x촬영 된 케이크의 비율입니다. 이 서핑 파도는 케이크의 절반 이하의 공평한 점유율 미만으로 시작하고 케이크 절반이 없어 질 때 그의 입찰가를 공정한 비율 바로 위까지 낮춘 다음 다시 속도를 올리는 가중치 기능으로 수정됩니다. 나중에 전체 케이크에 입찰합니다. 그는 남은 케이크의 공평한 비율에 5 % (즉, 전체 케이크의 퍼센트)를 더한 금액으로 입찰하지 않습니다.

그들이 형제 일지 모르지만 AlCakeBot보다 훨씬 더 큰 슬라이스를 얻는다면 후자는 그중 하나조차도 얻지 못합니다. 그들은 초콜릿이나 비스킷을 공유 하지만 케이크 는 공유 하지 않습니다!

배고픈, 자바

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

항상 남은 케이크의 공정한 분배를 원합니다.

모방 자, 루비

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

목표는 케이크를 극대화하지 않고 다른 사람보다 더 많은 케이크를 얻는 것입니다. 따라서이 봇은 이전 봇이 이미 취한 것보다 적지 않습니다. (이 버전은 그 검사에 휴리스틱을 사용합니다. 방금 상태를 저장할 수 있으므로 나중에 상태 저장 변형을 게시 할 것입니다).

정말 케이크, 배쉬

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

그리고 여기 진짜 케이크 사진이 있습니다.

케이크 먹는 사람, 자바

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

케이크를 먹는다. 그게 다야.

양도자, 자바

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

내 다른 봇의 기본 변형 인 참을성이 없습니다. 이것은 처음에 모든 것을 취하려고 시도하지만 점점 더 많은 손님이 자신의 몫을 얻음에 따라 가능한 한 천천히 얻는 욕구가 줄어 듭니다. 나는 이것에 너무하지 않습니다; 그것이 얼마나 잘되는지보고 싶을뿐입니다.

ALittleExtra, sh

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

조금만 더 먹고 싶어서 케이크가 줄어들면서 욕심이 덜 나옵니다

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

π를 정말 좋아하고 그 케이크를 생각합니다 방법 이다 π.

파이썬 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)

"완벽한"알고리즘은 케이크를 봇 사이에 골고루 분배하려고 시도하기 때문에 그보다 더 작은 조각을 사용합니다. 후속 라운드에서도 전체 케이크의 전체 공평한 분배를 요구하지만, 얼마나 많은 사람들이 남아 있는지에 따라 그 수를 증가시킵니다.

_{오랫동안 파이썬으로 프로그래밍하지 않았 으므로 코드가 손상되었는지 알려주세요 ...}