The Cake Cutting Contest

Question

It's my 17th birthday and you're invited to my party!

And as always at parties, there will be cake.

One cake...

And you need as much of it as possible.

As this is a fair party, each of us will say how much of my cake we want and the person who said the smallest amount will get it. Then everyone else gets to repeat the process until the cake is gone.

Challenge

• Given the input through command line arguments in the form of total-degrees degrees-left total-people people-left, output to standard output integer-bid-in-degrees.
• If your bid was the lowest, you receive that amount of cake and are out for the round.
• If your bid wasn't lowest, your bot gets to bid on the remaining cake.
• In the case that the lowest bids are the same, the person removed will be chosen at random.
• At the end of a round, once all the cake is gone or there is nobody left to bid on it, the person with the most cake wins!
• In the case at the end of a round and two people have the same sized biggest slice, the winner is chosen at random from the drawing entries.

Gameplay

• There will be 17 rounds, the overall winner will be the entry with the most wins overall.
• In the case of a draw, rounds will be played until there is a clear winner.
• Each day, I will update the current scores so that people can upgrade their entry.

Submission

You should write your entry as

Bot Name, Language

Insert
Code
Here

Explanation/Random stuff here

If your entry isn't formatted in this way, the controller will NOT be able to run your entry. If I find this has happened to your entry, I will either notify you in a comment, and/or edit the answer into the correct format.

Your entry and file storage

• Your bot may store files in the ./data/ directory and nowhere else.
  • Not required but please store your files as botname*
  • You may not write files in this format if botname is not your entries name.
  • This means you are allowed to overwrite other files you find that don't appear in this format. You shouldn't do this deliberately, please be sporting.
  • Your bot must not assume that the files it requires are present but it can assume ./data/ exists.
  • This is because I occasionally wipe the ./data directory, I will do this when the rounds actually start. (But not between them)
• Your bot may not delete files at all
• Your bot is only allowed to read files in the ./data/ directory
  • This means you may look at other entries files

Results:

Meek won the contest! Well done @Cabbie407

And now for some random stats:

A list of positions each bot came in: (Well done to any bot appearing in this list, you came in the top 5 at least once!)

1. Meek, Meek, Eidetic, Eidetic, Meek, Eidetic, Eidetic, Meek, Meek, Meek, Saucy, Meek, Givemethecake, Givemethecake, Givemethecake, Meek, 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, bill, bill, Relinquisher, MyFairPlusAThird

5. bill, MyFairPlusAThird, bill, bill, bill, bill, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, bill, Reallythecake, bill, ALittleOffTheTop, ALittleOffTheTop, bill, bill

The full log file for the cometition whilst running can be found here. Sorry about the format change partway through.

I will not be running the contest again, if you want to post more entries, you're welcome to do so, the controller can be found on my github repo for this contest.

Answer 1

FloorBot, Python

from sys import argv
from math import floor
degrees_left = int(argv[1])
print(floor(degrees_left*0.65))

Bids 65% of the remaining cake in hopes of beating both the greedy bots and the "Price is Right" bots.

Answer 2

this_bot_wants_it_all_possible, PHP

  echo 359;

This bot wants it all possible.

Answer 3

FairShare, Python 2

import sys

def FairShare(TotalDegrees, DegreesLeft, TotalPeople, PeopleLeft):
    
    FairShare = TotalDegrees / TotalPeople
    FairShareNow = DegreesLeft / PeopleLeft
    
    if PeopleLeft == 1:
        return DegreesLeft

    elif FairShare > FairShareNow:
        return FairShare
    
    elif FairShare == FairShareNow:
        return FairShare
    
    elif FairShare < FairShareNow:
        return FairShareNow

print FairShare(int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]))

Here I come with my tiny Python skills! :D max() and min() are things.

Pretty simple. If my fair share at the beginning is more than my fair share now, return my fair share now. If my fair share at the beginning is equal to to my fair share now, return my fair share at the beginning minus one. If my fair share at the beginning is less than my fair share now, return my fair share now.

Edited so that if FairShare is the last in the round, takes all the cake.

Answer 4

DruuuuuunkBot, Python

import sys,random
tD,dL,pN,pL=map(int,sys.argv[1:])
a=dL/(pL+1)
if a < 0:
 a = dL
print(a)

Tries to be educated in his guesses, but he's a tad drunk, resulting in wide errors. Said bot is now less drunk. He doesn't like people, so he just wants to get out of here pronto! But now he want a little more cake.

Answer 5

Try to Win, C++

#include<iostream>
#include<stdlib.h>
using namespace std;
int main(int argc, char *argv[])
{
    int td, dl, tp, pl;
    td = atoi(argv[1]);
    dl = atoi(argv[2]);
    tp = atoi(argv[3]);
    pl = atoi(argv[4]);
    if (pl == 1)
    {
        cout << dl;
        return 0;
    }
    else if(pl < 10 )
    {
        int sn = dl / pl;
        int sb = td/ pl;
        int si = td / tp;

        if (sn > si + 1)
        {
            cout << sn;
            return 0;
        }
        if (sn = si + 1)
        {
            cout << sn;
            return 0;
        }
        if (sn == si)
        {
            cout << sn;
            return 0;
        }
        if (sn < si)
        {
            cout << si;
            return 0;
        }

    }
    else
    {
          cout<<td/13;
    }
    return 0;
}

Answer 6

Fatbot 5000, Python 2

import random, math, sys

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

def get_equal_share(degrees_left, people):
    return int(math.ceil(degrees_left/float(people)))

def get_greedy(degrees_left, people):
    min_bid = get_equal_share(degrees_left,people)+1
    max_bid = min_bid*2
    bid = random.randrange(min_bid, max_bid)
    return min(bid, degrees_left)

print get_greedy(degrees_left, people_left)

My example bot. Will always bid more than it's fair share of the cake but isn't so hungry it wants much more than 2 times it's fair share.

Answer 7

Moses, Java

public class Moses {
    public static void main(String[] args) {
        double[] arguments = new double[4];
        for (int i = 0; i < 4; i++) {
            arguments[i] = Double.parseDouble(args[i]);
        }
        if (arguments[3] == 1) {
            System.out.println((int)arguments[3]);
        } else {
            int myCake = (int) Math.ceil(arguments[1]/2);
            System.out.println(myCake);
        }
    }
}

Wants half of the pie. If it gets its share, the following players can at maximum get the same amount.

Answer 8

FairPlusPlus, Java

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.util.Scanner;
import static java.lang.Math.*;

/**
 * Created 10/5/15
 *
 * @author TheNumberOne
 */
public class FairPlusPlus {

    private static int previousCake;
    private static int highestVoteWon;

    static {
        File file = new File("data/FairPlusPlus.txt");
        Scanner in = null;
        try {
            in = new Scanner(file);
            previousCake = in.nextInt();
            highestVoteWon = in.nextInt();
        } catch (Exception ignored) {
        }
    }

    public static void main(String[] arguments) throws FileNotFoundException {
        double[] args = new double[4];
        for (int i = 0; i < 4; i++) {
            args[i] = Double.parseDouble(arguments[i]);
        }
        if (args[2] == args[3]){
            highestVoteWon = -1;
        } else {
            highestVoteWon = (int) max(highestVoteWon, args[1] - previousCake);
        }

        System.out.println((int) min(max(ceil(args[1]/args[3]+(args[3]-1)/2), highestVoteWon + 1), args[1]));

        PrintStream out = new PrintStream("data/FairPlusPlus.txt");
        out.println((int) args[1]);
        out.println(highestVoteWon);

    }

}

He's mostly fair ... unless someone gets the better of him.

Assumes ./data/ directory exists.

Answer 9

Impatient, Java

import static java.lang.Integer.parseInt;
public class Impatient {
    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(((totalPeople - peopleLeft + 10.0) * cakeLeft) / (totalPeople + 10.0));
        System.out.println((int) answer);
    }
}

I don't really know Java, so I don't even know if this will compile....

It starts out hungry for 10/(totalPeople+10) of the cake, getting hungrier and hungrier as the round wears on. Not sure how it will do, but it's a fun experiment.

Answer 10

Give me the cake, Bash

#!/bin/bash
echo 3594

Answer 11

Pig, Java

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

This pig is probably not smart enough to bid low.