มันเป็นวันเกิดปีที่ 17 ของฉันและคุณได้รับเชิญไปงานเลี้ยงของฉัน!

และเช่นเคยในงานปาร์ตี้จะมีเค้ก

หนึ่งเค้ก ...

และคุณต้องการมากที่สุด

เนื่องจากนี่เป็นปาร์ตี้ที่ยุติธรรมเราแต่ละคนจะพูดว่าเค้กที่ฉันต้องการและคนที่พูดว่าจำนวนที่น้อยที่สุดจะได้รับมัน จากนั้นทุกคนจะต้องทำซ้ำจนกว่าเค้กจะหมด

ท้าทาย

• ได้รับการป้อนข้อมูลผ่านอาร์กิวเมนต์บรรทัดคำสั่งในรูปแบบของการส่งออกการส่งออกมาตรฐานtotal-degrees degrees-left total-people people-leftinteger-bid-in-degrees
• หากการเสนอราคาของคุณต่ำที่สุดคุณจะได้รับเค้กและออกไปในรอบนั้น
• หากการเสนอราคาของคุณไม่ต่ำสุดบ็อตของคุณก็จะเสนอราคาเค้กที่เหลือ
• ในกรณีที่การเสนอราคาต่ำสุดเท่ากันผู้ที่ถูกลบออกจะถูกสุ่มเลือก
• ในตอนท้ายของรอบเมื่อเค้กทั้งหมดหายไปหรือไม่มีใครเหลือที่จะเสนอราคาให้กับคนที่ชนะเค้กมากที่สุด!
• ในกรณีที่สิ้นสุดรอบและคนสองคนมีชิ้นที่ใหญ่ที่สุดเท่ากันผู้ชนะจะถูกสุ่มเลือกจากรายการวาด

เพลย์

• จะมี 17 รอบ, ผู้ชนะโดยรวมจะเป็นรายการที่มีผู้ชนะมากที่สุดโดยรวม
• ในกรณีที่เสมอจะมีการเล่นรอบจนกว่าจะมีผู้ชนะที่ชัดเจน
• ในแต่ละวันฉันจะอัปเดตคะแนนปัจจุบันเพื่อให้ผู้คนสามารถอัปเกรดรายการได้

ส่ง

คุณควรเขียนข้อความของคุณเป็น

ชื่อบอทภาษา

Insert
Code
Here

คำอธิบาย / สิ่งสุ่มที่นี่

หากรายการของคุณไม่ได้จัดรูปแบบด้วยวิธีนี้ผู้ควบคุมจะไม่สามารถเรียกใช้รายการของคุณได้ หากฉันพบสิ่งนี้เกิดขึ้นกับข้อมูลของคุณฉันจะแจ้งให้คุณทราบในความคิดเห็นและ / หรือแก้ไขคำตอบในรูปแบบที่ถูกต้อง

รายการและการจัดเก็บไฟล์ของคุณ

• บอทของคุณอาจเก็บไฟล์ไว้ใน./data/ไดเรกทอรีและไม่มีที่อื่นอีกแล้ว
  • ไม่จำเป็น แต่โปรดเก็บไฟล์ของคุณเป็น botname*
  • คุณไม่สามารถเขียนไฟล์ในรูปแบบนี้หากbotnameไม่ใช่ชื่อรายการของคุณ
  • หมายความว่าคุณได้รับอนุญาตให้เขียนทับไฟล์อื่น ๆ ที่คุณพบว่าไม่ปรากฏในรูปแบบนี้ คุณไม่ควรทำสิ่งนี้โดยเจตนาโปรดเป็นกีฬา
  • บอทของคุณต้องไม่สมมติว่าไฟล์ที่ต้องการนั้นมีอยู่ แต่สามารถสันนิษฐานได้ว่า./data/มีอยู่
  • นี่เป็นเพราะฉันเช็ด./dataไดเรกทอรีบางครั้งฉันจะทำเมื่อเริ่มรอบจริง (แต่ไม่ใช่ระหว่างพวกเขา)
• บอทของคุณอาจไม่ลบไฟล์เลย
• บอตของคุณได้รับอนุญาตให้อ่านไฟล์ใน./data/ไดเรกทอรีเท่านั้น
  • ซึ่งหมายความว่าคุณอาจดูไฟล์รายการอื่น ๆ

ผล:

ถ่อมตนชนะการประกวด! ทำได้ดีมาก @ Cabbie407

และตอนนี้สำหรับสถิติสุ่มบางอย่าง:

รายการตำแหน่งที่บอทแต่ละคนเข้ามา: (ทำได้ดีกับบอทใด ๆ ที่ปรากฏในรายการนี้คุณเข้ามาอยู่อันดับ 5 อย่างน้อยหนึ่งครั้ง!)

1. ถ่อมตน, ถ่อมตน, Eidetic, Eidetic, ถ่อมตน, Eidetic, Eidetic, ถ่อมตน, ถ่อมตน, ถ่อมตน, ถ่อมตน, ทะลึ่ง, Givemethecake, Givemethecake, Givemethecake, ถ่อมตน, Eidetic

2. Eidetic, Eidetic, ถ่อมตน, AlCakeSurfer, Eidetic, AlCakeSurfer, ถ่อมตน, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, MyFairPlusAThird, MyFairPlusAThird, ถ่อมตัว

3. Reallythecake, AlCakeSurfer, AlCakeSurfer, ถ่อมตน, AlCakeSurfer, ถ่อมตน, AlCakeSurfer, AlCakeSurfer, AlCakeSurfer, ถ่อมตัวเอง, ECATESSIRFER, EIRetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic

4. ฟรี

5. บิล, MyFairPlusAhird, บิล, บิล, บิล, เรียกเก็บเงิน, Relinquisher, MyFairPlusAThird, ปลดล็อก, บิล, Reallythecake, บิล, ALittleOffTheTop, ALittleOffTheTop, บิล, บิล

แฟ้มบันทึกเต็มรูปแบบสำหรับ cometition ขณะที่ทำงานที่สามารถพบได้ที่นี่ ขออภัยเกี่ยวกับการเปลี่ยนแปลงรูปแบบบางส่วนผ่าน

ฉันจะไม่เปิดการแข่งขันอีกครั้งหากคุณต้องการโพสต์ข้อความเพิ่มเติมคุณยินดีที่จะทำเช่นนั้นตัวควบคุมสามารถพบได้บนgitub repo ของฉันสำหรับการประกวดครั้งนี้

ถ่อมตัว, 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 นั้นน่าอัศจรรย์

_{นี่คือการทดสอบตัวควบคุมและไม่ได้เป็นรายการที่ร้ายแรง}

ผอมเพรียว 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 เพียงต้องการส่วนที่เท่ากัน :(

เขาต้องการแบ่งเค้กให้เท่า ๆ กันในหมู่ผู้เข้าร่วมทั้งหมด

(เขาคาดหวังว่าบ็อตอื่น ๆ จะฉุดเขาออกไปเพราะเขารู้ว่าพวกมันหมายถึง)

(ชอบจริงๆเขาเหงาเขาแค่อยากให้บอทคนอื่นชอบเขา)

(เขาเพิ่งออกจากความสัมพันธ์ที่ไม่ดีและกำลังจะผ่านแผ่นปะที่ขรุขระจริง ๆ ดังนั้นถ้าคุณสามารถให้เขาตบหลังและรอยยิ้มเพื่อทำให้เขารู้สึกดีขึ้นมันจะมีความหมายมากจริงๆ)

แก้ไขเปลี่ยนโปรแกรมเพื่อรับข้อมูลจาก argv / c แทนที่จะเป็น stdin (บอทยุติธรรมยังคงเศร้า ... เขาต้องการเปลี่ยนชื่อของเขาเป็น sadbot (ซึ่งค่อนข้างเป็นเหตุผลว่าทำไมเขาถึงต้องการเค้ก)

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

ละเอียดรอบคอบยุติธรรมอย่างไร้ที่ติ เค้กครึ่งหนึ่งสำหรับฉันครึ่งเค้กสำหรับคนอื่น ๆ

CharityBot, Python 2

print -360

เพิ่มเค้กอีกชิ้นลงในส่วนผสม!

(ผู้ควบคุมจะเห็นสิ่งนี้เป็นคำขอ 0 เค้กจะไม่เพิ่มขนาดของเค้กจริง ๆ )

โอ่อ่าผู้ยิ่งใหญ่, 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))

Variant of Imitator (หากคุณต้องการเพียงหนึ่งรายการต่อผู้เล่นหนึ่งคนนี้จะแทนที่สิ่งนั้น) ติดตามชิ้นที่ใหญ่ที่สุดได้อย่างแม่นยำแล้วและเสนอราคามากพอที่จะเอาชนะชิ้นนั้นเสมอ จะไม่เสนอราคาต่ำกว่าส่วนแบ่งที่เป็นธรรมของส่วนที่เหลือ ถือว่าไดเรกทอรี './ata' อ่าน / เขียนได้มีอยู่แล้ว ไฟล์สามารถมีอยู่แล้วหรือไม่

Dieter, Java

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

มันไม่ได้ต้องการเสนอราคาสำหรับเค้กมากเกินไปดังนั้นจึงเลือกขนาดเล็ก แต่รับประกันสุ่มชิ้น

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

คุณเคยลองจัดประกวดเค้กตัดกับเลื่อยไฟฟ้าหรือไม่? ตอนนี้คุณมี มันค่อนข้างจะก่อกวน

สุภาพบุรุษ, 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;
    }
}

เขารอคนที่กินพอใช้หรือน้อยกว่าก่อนที่เขาจะกินเค้กใด ๆ เพื่อป้องกันความโลภที่จะได้รับเค้กพิเศษเขาใช้เวลาส่วนใหญ่เป็นไปได้

Bob Barker, Java

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

นี่อาจจะถูกแทนที่ด้วยวิธีแก้ปัญหาที่คิดมากขึ้นในภายหลัง แต่ฉันอยากรู้ว่ามันจะใช้งานได้หรือไม่ นี่เป็นเพียงการจับบ็อตใด ๆ ที่พยายามอย่างเต็มที่และทำราคาที่ถูกต้องเป็นกลยุทธ์เพื่อขโมยคำตอบ อาจนำไปสู่การเพิ่มด้วยการลบจำนวนเต็มที่เพิ่มขึ้น

แก้ไข: เริ่มการยกระดับตอบโต้การโพสต์กับ FloorBot

Eidetic, Python 2

import random, math, sys, json

total_degrees, degrees_left, total_people, people_left = map(int, sys.argv[1:])
#try:
#    inp_f = open("./data/Eidetic.json", "r")
#    out = json.load(inp_f)
#except (IOError, ValueError):
out = {"last_cake": 0,
           "runs": 0,
           "total_runs": 0,
           "total_rounds": 0,
           "training":  [[0.0], [0.0], [0.12903225806451613], [16.774193548387096], [400.83870967741933], [720.0], [995.8709677419355], [996.9437634408603], [997.6], [997.6], [997.6], [998.5991397849463], [996.6770967741936], [998.8122580645161], [1011.5467420570814], [1017.7717824448034], [1227.155465805062], [1280.7840603123318], [1435.8028540656974], [1553.3689822294023], [1793.5330640818527], [2299.178101402373], [3183.924709689701], [2231.666666666667], [2619.4789644012944], [1270.9288025889969], [741.2718446601941], [480.4757281553398], [122.66990291262135], [27.54736842105263]]}

#else: inp_f.close()

def write_out():
    out_f = open("./data/Eidetic.json", "w")
    out_f.write(json.dumps(out))
    out_f.close()

def get_last_winner(): # Find the bid of the last winner
    bid = out["last_cake"]
    return max(bid, degrees_left) - degrees_left

def train():
#    print degrees_left # If you get that much, your probably safe.
#    sys.stderr.write("\nEidetic - Training len %s, no runs: %s, no_rounds: %s, last winner: %s\n"%(len(out["training"]), out["runs"], out["total_rounds"], get_last_winner()))
    if len(out["training"]) <= out["runs"]: out["training"].append([])
    out["training"][out["runs"]].append(get_last_winner())

def get_best_round():
    data = out["training"][out["runs"]+1:]
    mean = [sum(i)/(float(len(i)) or 1) for i in data]
    bid = max(mean+[0]) - 0.5
    sys.stderr.write("\nEidetic - mean %s\n"%mean)
    return bid

def main():
    reset = total_people == people_left
    if reset:
        out["total_rounds"] += 1
        out["runs"] = 0
    train()
    bid = get_best_round()
    print bid
#    sys.stderr.write('\nEidetic Bid: '+str(bid)+'\n')
    out["total_runs"] += 1
    out["runs"] += 1
    out["last_cake"] = degrees_left
    write_out()

main()

ฉันวิ่งบอทนี้ในตัวควบคุมสองสามครั้งเพื่อฝึกฝนมันขึ้นมาเล็กน้อยมันจำการเสนอราคาที่จำเป็นในการชนะในแต่ละรอบและเมื่อผ่านการฝึกฝนแล้วมันจะออกไปสู่โลกแห่งความเป็นจริงและโหวตด้วยคนอื่น ๆ

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

นี่เป็นโพสต์ 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..]...))

อะไรคือเค้กที่ไม่มีกาแฟดี

The 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, Python

import sys

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

print(round(degreesleft/peopleleft))

IWMBAICBIWT (มันเป็นวันเกิดของฉันและฉันร้องไห้เพราะฉันต้องการ) สมมติว่ามีความสัมพันธ์ระหว่างองศาที่เหลือและจำนวนคนที่เหลือ หวังว่ามันจะใช้งานได้!

ควรทำงานในงูหลามทั้งหมด

แก้ไข:

การจัดเก็บsys.argvในอินพุตค่อนข้างสิ้นเปลือง ...

ผู้เยี่ยมชม Python 2

print ord('d')*4

ใบแจ้งหนี้ Python 2

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

เดิมพันที่เป็นธรรม

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

เนื่องจาก 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);
    }
}

ต้องการส่วนแบ่งที่ยุติธรรมของเค้กที่เหลืออยู่เสมอ

ตัวลอกเลียนแบบ 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))

เป้าหมายคือการได้รับเค้กมากกว่าคนอื่นไม่เพิ่มเค้กของคุณ ดังนั้นบอทนี้จะไม่ชำระใด ๆ น้อยกว่าบอตก่อนหน้านี้ที่ได้ทำไปแล้ว (รุ่นนี้ใช้ฮิวริสติกสำหรับการตรวจสอบนั้นฉันเพิ่งสังเกตว่าเราได้รับอนุญาตให้บันทึกสถานะจริงดังนั้นฉันอาจจะโพสต์ตัวแปรที่ไม่เหมาะสมในภายหลัง)

จริง ๆ แล้วเค้ก Bash

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

และนี่คือภาพเค้กจริง

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

มันกินเค้ก เกี่ยวกับมัน.

ปล่อยอีกครั้ง, 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);
    }
}

ตัวแปรพื้นฐานของบอตอื่น ๆ ของฉันคือใจร้อน สิ่งนี้พยายามที่จะทำสิ่งทั้งหมดในตอนแรก แต่เมื่อแขกจำนวนมากขึ้นและได้รับส่วนแบ่งความปรารถนาที่จะได้รับช้าที่สุดที่เป็นไปได้ ฉันไม่ได้เป็นคนนี้เกินไป แค่อยากเห็นว่ามันทำได้ดีแค่ไหน

ALittleExtra, sh

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

ฉันแค่ต้องการเพิ่มอีกนิดรับความโลภน้อยลงเมื่อเค้กเบาบางลง

MyFairPlusAv แปลก

#!/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);

ชอบπและคิดว่าเค้กนั้น วิธี คือ π

A Little Off The Top, 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)

เนื่องจากอัลกอริธึม "สมบูรณ์แบบ" พยายามแบ่งเค้กให้เท่ากันระหว่างบ็อตเราจะใช้เศษไม้น้อยกว่านั้น เรียกร้องให้มีการแบ่งเค้กอย่างเต็มที่แม้ในรอบต่อมา แต่จะมีจำนวนที่สูงขึ้นเพราะมันขึ้นอยู่กับจำนวนคนที่เหลือ

_{ฉันไม่ได้ตั้งโปรแกรมใน Python มานานแล้วโปรดแจ้งให้เราทราบหากรหัสของฉันเสีย ...}