केक काटने की प्रतियोगिता

37

यह मेरा 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. 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, MyFairPlusATirdaddirdat

  3. सच में सेंकना, AlCakeSurfer, AlCakeSurfer, Meek, AlCakeSurfer, Meek, AlCakeSurfer, AlCakeSurfer, Truethecake, AlCakeSurfer, Meek, MyFairPlusAThird, Eidetic, Eidetic, Eidetic, Eidetic, Eidetic

  4. AlCakeSurfer, Truethecake, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, Eidetic, AlCakeSurfer, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird, MyFairPlusAThird

  5. बिल, MyFairPlusAThird, बिल, बिल, बिल, बिल, Relinquisher, Relinquisher, MyFairPlusAThird, Relinquisher, बिल, वास्तव में, बिल, ALFOffTheTop, ALittleOffTheTop, बिल, बिल

धूमकेतु के चलने की पूरी लॉग फ़ाइल यहां पाई जा सकती है । प्रारूप परिवर्तन के माध्यम से भाग के बारे में क्षमा करें।

मैं प्रतियोगिता को फिर से नहीं चलाऊंगा, यदि आप अधिक प्रविष्टियाँ पोस्ट करना चाहते हैं, तो आप ऐसा करने के लिए स्वागत करते हैं, इस प्रतियोगिता के लिए नियंत्रक को मेरे गितुब रेपो पर पाया जा सकता है ।

game  king-of-the-hill 
— नीला
स्रोत
10
मैं बाहर की परिधि के चारों ओर रिंग कट का अनुरोध करता हूं। तकनीकी रूप से 0 डिग्री (केक में अभी भी 360 डिग्री है जब मैं कर रहा हूँ, सब के बाद) और मुझे सभी साइड आइसिंग मिलती है।
— रैंडम 832
10
जन्मदिन मुबारक हो :)
— TheNumberOne
2
किसी के इच्छुक होने पर एक राउंड के लिए परिणाम {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']। यदि आपके बॉट का स्कोर 0 है, तो यह कुछ गलत कर रहा है।
— ब्लू
3
कृपया अधिक रीडर-फ्रेंडली तरीके से लीडरबोर्ड को प्रारूपित करें।
— SuperJedi224
2
@ मुडीफिश ग्रेडियन? केक वाले को ज्यादा पसंद है, है ना?
— जनवरी

जवाबों:

5

मीक, जाग

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

मैंने इसे एक बार सिमुलेशन में देखा था।

— Cabbie407
स्रोत
एक उत्थान है, अपने बॉट कर रहे हैं बहुत अच्छी तरह से = हे
— जन
धन्यवाद। वैसे यह कोई संयोग नहीं है। मैंने वास्तव में नियंत्रक को स्वयं चलाया, एक स्मार्ट बॉट लिखने की कोशिश की। लेकिन ज्यादातर समय यह सबसे साधारण बॉट्स द्वारा पीटा गया था। इसलिए मैंने एक बहुत ही सरल रणनीति का उपयोग करते हुए अंत किया, जो ज्यादातर समय एक यादृच्छिक आकार के केक के साथ जीता।
— काबी ४०
13

जादूगर, जावा

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

720 नंबर जादुई है।

यह है नियंत्रक का परीक्षण करने के लिए था और है नहीं एक गंभीर प्रविष्टि।

— नंबर एक
स्रोत
3
मुझे लगता है कि यह वास्तव में प्रतियोगिता जीत रहा था जिस तरह से यह मूल रूप से 720 के स्कोर के साथ यहां था ।
— PhiNotPi
10

सदबोट :(, सी ++

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

पूर्व में फेयरबॉट

फेयरबॉट सिर्फ एक बराबर हिस्सा चाहता है :(

वह सभी प्रतिभागियों के बीच केक को समान रूप से विभाजित करना चाहता है।

(वह पूरी तरह से उम्मीद करता है कि अन्य बॉट्स उसे चीर देंगे, क्योंकि वह जानता है कि वे मतलबी हैं)

(वास्तव में पसंद है। वह अकेला है, वह चाहता है कि अन्य बॉट उसे पसंद करें)

(वह सिर्फ एक खराब रिश्ते से बाहर निकला और वास्तव में एक कठिन पैच के माध्यम से जा रहा है, इसलिए यदि आप उसे पीठ पर एक थपकी दे सकते हैं और उसे बेहतर महसूस करने के लिए एक मुस्कान दे सकते हैं तो यह वास्तव में बहुत मायने रखेगा।)

EDIT ने स्टडिन के बजाय argv / c से इनपुट लेने के लिए प्रोग्राम बदल दिया (फेयर बॉट अभी भी दुखी है .... वह अपना नाम सैडबोट में बदलना चाहता है (जो थोड़े इसी कारण वह केक चाहता है))

— लियाम
स्रोत
क्या आप इसे बना सकते हैं ताकि यह स्टड के बजाय arvv से आर्गल्स ले सके?
— ब्लू
जैसा कि आपने आज्ञा दी है, इसलिए यह किया जाता है।
— लियाम
1
आप चाहें तो अपना नाम बदलकर सैडबोट रख सकते हैं।
— ब्लू
इसके अलावा, कोष्ठकों को कोड ब्लॉक
— ब्लू
1
और इसलिए वह एक उदास बॉट है।
— लियाम
9

हाल्वर, रूबी

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

विचित्र रूप से, बेदाग निष्पक्ष। मेरे लिए आधा केक, बाकी सभी के लिए आधा केक।

— histocrat
स्रोत
8

चैरिटीबॉट, पायथन 2

print -360

मिश्रण के लिए एक और केक जोड़ता है!

(नियंत्रक इसे 0 केक के अनुरोध के रूप में देखेंगे, वास्तव में केक के आकार में नहीं जोड़ा जाएगा)

— नीला
स्रोत
7

स्टेली इमिटेटर, रूबी

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' निर्देशिका पहले से ही मौजूद है; फ़ाइलें या तो पहले से ही हो सकती हैं या नहीं।

— histocrat
स्रोत
यदि आपने ध्यान नहीं दिया, तो मेरे पास कई उत्तर भी हैं (लेकिन उनमें से केवल एक ही समझदार है)
— ब्लू
अच्छी खबर और बुरी है। बुरा - एक ऐसा सा है जो आपकी कॉन्फिग फाइलों को बदल देता है। अच्छा - आपका बॉट वास्तव में बेहतर करता है! 505/3600, इसने आखिरी राउंड जीता जो मैंने किया था!
— ब्लू
6

डाइटर, जावा

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

यह बहुत अधिक केक के लिए बोली नहीं लगाना चाहता है, इसलिए यह एक छोटा लेकिन गारंटीकृत यादृच्छिक टुकड़ा चुनता है ।

— DankMemes
स्रोत
1
यदि आप मेरे पोस्ट को कम करते हैं तो कृपया बताएं कि क्यों। वरना मैं कभी नहीं सुधर सकता!
— DankMemes
18
ओह। मैंने सिर्फ अनुमान लगाया कि आप अनुमान लगा सकते हैं कि ऐसा इसलिए था क्योंकि ऐसा प्रतीत होता है कि आप हंसी / वोटों के लिए एक एक्सकैंडी रेफरी का इस्तेमाल कर रहे हैं, इस बात का ध्यान नहीं रखते हुए कि यह संभवतः एक भी गेम नहीं जीत पाएगा।
— ज्योबिट्स
3
हमारे पास नकली रैंडम नंबरों (जिसमें यह विशेष रूप से xkcd स्पष्ट रूप से संदर्भित है) के उपयोग को संबोधित करने वाला एक मानक लूपहोल है । चूंकि चुनौती को प्रस्तुतियाँ में यादृच्छिकता की आवश्यकता नहीं होती है , यह जरूरी नहीं कि खामियों का उल्लंघन है, लेकिन फिर भी। ಠ_
— एलेक्स ए।
3
मुझे लगता है कि समझ में आता है, लेकिन अगर किसी ने आपके "कुछ बेवकूफी" को कम कर दिया तो आश्चर्यचकित न हों ।
— जिओबिट्स
2
बिना किसी हास्य के लोगों का मुकाबला करने के लिए वोट करें
— बॉबी
5

ज्वलंत चेनसॉ, जावा

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

क्या आपने कभी चेनसॉ के साथ केक काटने की प्रतियोगिता आयोजित करने की कोशिश की है? अच्छा, अब आपके पास है। यह बल्कि विघटनकारी है।

— PhiNotPi
स्रोत
2
मुझे लगता है कि मैं आमतौर पर चेनसॉ शोर को बाहर निकाल सकता हूं, लेकिन यह सुनिश्चित करता है कि जब आप केक काटने के लिए इसका उपयोग करते हैं तो यह गड़बड़ करता है।
— एलेक्स ए।
3
यह मोमबत्तियों को प्रकाश देने का एक विदेशी तरीका है।
— TheNumberOne
5

सज्जन, जावा

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

वह उन लोगों की प्रतीक्षा करता है जो किसी भी केक को खाने से पहले एक उचित हिस्सा या उससे कम खाते हैं। लालची को अतिरिक्त केक प्राप्त करने से रोकने के लिए, वह यथासंभव बड़ा हिस्सा लेता है।

— नंबर एक
स्रोत
4

बॉब बार्कर, जावा

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

यह शायद बाद में एक और अधिक सोचा समाधान के साथ प्रतिस्थापित किया जा रहा है, लेकिन मैं उत्सुक हूं कि यह काम करेगा। यह केवल किसी भी बॉट को पकड़ने की कोशिश है जो अधिकतम करने की कोशिश करता है, और एक संशोधित मूल्य करता है उनके जवाब को चोरी करने के लिए सही रणनीति है। बढ़ते पूर्णांक घटाव के साथ वृद्धि हो सकती है, जो साफ-सुथरी होगी।

संपादित करें: वृद्धि शुरू होती है, फ्लोरबॉट के खिलाफ जवाबी पोस्टिंग

— thefistopher
स्रोत
मैंने चुनौती के प्रारूपण आवश्यकताओं से मेल करने के लिए आपके विवरण को नीचे तक ले जाया।
— PhiNotPi
@PhiNotPi, woops, उस आवश्यकता के बारे में भूल गए। इसे ठीक करने के लिए धन्यवाद!
— Thefistopher
— हाह
खैर, उत्तर पार्सर पहली पंक्ति और फिर पहले कोड ब्लॉक पर दिखता है। इसके अलावा, आपको args[1]घटाव करने से पहले एक इंट में बदलने की आवश्यकता है ।
— ब्लू
@ वेफिस्टोफर के लिए आपको अभी भी अंतर रूपांतरण करने की आवश्यकता है
— ब्लू
4

ईडिटिक, पायथन 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()

मैंने इस बॉट को कंट्रोलर में एक दो बार चलाने के लिए इसे थोड़ा सा प्रशिक्षित किया, यह प्रत्येक राउंड को जीतने के लिए आवश्यक बोलियों को याद करता है और फिर एक बार प्रशिक्षित होने के बाद, यह वास्तविक दुनिया में चला जाता है और उनमें से बाकी के साथ वोट करता है।

— नीला
स्रोत
यह एक चतुर तरीका है; अब आप पैक से आगे हैं। मुझे आश्चर्य है कि अगर यह अभी भी
— एकतरफा
3

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

यह मेरी पहली पीसीजी पोस्ट है; मुझे उम्मीद है कि यह काम करता है ...

मुझे केक पसंद है। कोई फर्क नहीं पड़ता। मेरे साथियों को पता है। और इसलिए मेरे बॉट करता है। यदि पूरा केक अभी भी है, तो वह इसके आधे हिस्से के लिए बोली लगाएगा, जिससे सबसे बड़ी टुकड़ा तुरंत प्राप्त करने की उम्मीद है। यदि नहीं, तो उसे वेटिंग फंक्शन ( ½ + sin² (fraction gone) / 2) के रूप में स्क्वार्ड साइन का उपयोग करते हुए आधे बचे हुए केक और बचे हुए केक के बीच कुछ के लिए बोली लगानी चाहिए । तर्क यह दिया जा रहा है कि खेल में शुरुआती बड़े (लेकिन आंशिक रूप से छोटे) स्लाइस के लिए एक मौका होना चाहिए और देर से खेल में एक सज्जन बनने की कोशिश में बहुत कम बिंदु हैं।

चूंकि मैं प्रोग्रामिंग में बहुत अधिक नहीं हूं, इसलिए मैं इंगित की गई किसी भी त्रुटि की सराहना करूंगा। अब चलो कुछ केक = डी खाएं

— जनवरी
स्रोत
3

सॉसी, रूबी

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

सॉसी शेष केक के आधे से थोड़ा कम स्वीकार करने के लिए तैयार है, इसलिए जब तक यह किसी और से अधिक हो गया है या प्राप्त करने की संभावना है (गुप्त सॉस के आधार पर)।

— histocrat
स्रोत
3

CoffeeJunkie, कॉफ़ीस्क्रिप्ट

#!/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 केक के एक टुकड़े पर कॉफी पसंद करता है, लेकिन फिर भी कुछ कोशिश करना चाहता है। वह हमेशा अन्य प्रतिभागियों के लिए उचित होगा और यह याद रखने की कोशिश करेगा कि आखिरी केक का क्या हुआ। हालाँकि, उनकी अत्यधिक कॉफी की खपत ने उनकी यादों को कमजोर कर दिया है ...

— सिफ़र
स्रोत
क्या आप नोड.जेएस की या तो कॉफ़ीस्क्रिप्ट के लिए भाषा का नाम बदल सकते हैं?
— ब्लू
हो गया, हालांकि आपको चलाने और स्थापित करने के लिए नोड.जेएस की आवश्यकता है:npm install -g coffee-script; coffee CoffeeJunkie.coffee
— सिफर
क्या आप सुनिश्चित हैं कि आपके केक पर एक मोमबत्ती है? यह थोड़ा अधिक दिखता है ... phallic: D
— Beta Decay
@BetaDecay ... कोई बेहतर? : डी
— सिफर
@ सिफर यह अच्छा है: D
— बीटा डिके
2

स्टेली सबोटेज, रूबी

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 की दृढ़ता फ़ाइलों को गड़बड़ करता है (क्योंकि वे बॉट नाम के साथ उपसर्ग नहीं कर रहे हैं) ताकि यह गलत निर्णय लेता है और अंतिम चुना जाता है।

— Riking
स्रोत
1
'आपको यह जानबूझकर नहीं करना चाहिए' क्या यह गिनती नहीं है?
— ब्लू
3
यही कारण है कि हम अच्छी चीजें नहीं कर सकते हैं।
— हिस्टोक्रेट
@ मुड्डीफिश मैंने इसे RFC2119 अर्थों में लिया। "विशिष्ट परिस्थितियों में मान्य कारण मौजूद हो सकते हैं जब विशेष व्यवहार स्वीकार्य या उपयोगी हो, लेकिन पूर्ण निहितार्थों को समझा जाना चाहिए"
— बाइक चलाना
2

व्यापारी, आर

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।

— plannapus
स्रोत
2

IWMBAICBIWT, पायथन

import sys

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

print(round(degreesleft/peopleleft))

IWMBAICBIWT (यह मेरा जन्मदिन था और मैं रोया क्योंकि मैं चाहता था) मान लेता है कि डिग्री के बीच एक रिश्ता है और बचे हुए लोगों की संख्या है। आशा है कि यह काम करता है!

सभी पायथन में काम करना चाहिए।

संपादित करें:

sys.argvइनपुट्स में स्टोर करना थोड़ा बेकार था ...

— बीटा डिके
स्रोत
यह होना चाहिए degreesleft = int(inputs[2]); peopleleft = int(inputs[4])और यह हर समय 1 बोली लगा रहा है
— ब्लू
@ मड्डीफिश संपादित
— बीटा
2

अतिथि, अजगर २

print ord('d')*4
— user193661
स्रोत
3
यह वह कोड गोल्फ नहीं है जिसे आप जानते हैं;)
— ब्लू
2

बिल, अजगर २

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

एक निष्पक्ष शर्त।

— user193661
स्रोत
2

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 की तुलना में काफी बड़ा टुकड़ा मिलता है, तो बाद वाले को एक भी टुकड़ा नहीं मिल रहा है। वे चॉकलेट या बिस्कुट साझा करेंगे, लेकिन केक नहीं!

— जनवरी
स्रोत
वाह, मैं शुरुआती दौर में भाग्यशाली रहा और दूसरों के बॉट्स को अनुकूलित करने के बाद यह जल्दी ही साउथ चला गया = O
— Jan
1

भूख, जावा

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

हमेशा शेष केक का अपना उचित हिस्सा चाहता है।

— CommonGuy
स्रोत
1

इमीटेटर, रूबी

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

लक्ष्य किसी और से अधिक केक प्राप्त करना है, न कि आपके केक को अधिकतम करना। इस प्रकार, यह बॉट किसी भी पिछले बॉट की तुलना में कम के लिए व्यवस्थित नहीं होगा। (यह संस्करण उस जाँच के लिए उत्तराधिकार का उपयोग करता है, मैंने अभी ध्यान दिया है कि हमें वास्तव में राज्य को बचाने की अनुमति है इसलिए मैं बाद में एक राज्यीय संस्करण पोस्ट करूँगा)।

— histocrat
स्रोत
1

वास्तव में केक, बैश

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

और यहाँ असली केक की एक तस्वीर है।

वास्तविक केक की एक तस्वीर

— जेम्स
स्रोत
1

केक ईटर, जावा

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

यह केक खाता है। यह इसके बारे में।

— SuperJedi224
स्रोत
1

रेलिंकर, जावा

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

मेरे अन्य बॉट का एक मूल संस्करण, अधीर। यह पहली बार में पूरी बात लेने की कोशिश करता है, लेकिन जैसे-जैसे अधिक से अधिक मेहमानों को अपना हिस्सा मिलता है, सबसे अधिक संभव धीरे-धीरे पाने की इसकी इच्छा कम हो जाती है। मैं इस एक में नहीं हूँ; बस देखना है कि यह कितना अच्छा करता है।

— ETHproductions
स्रोत
जरूरत है ; मैथ्यू लाइन में
— ब्लू
@ मड्डीफिश व्हाट्स, सोचा कि मैंने इसे पहले वहाँ रखा था। यह बात बताने के लिए धन्यवाद!
— ETHproductions
इसके अलावा एक इंट के रूप में कास्ट करने की आवश्यकता है जैसे कि एक अन्य
— ब्लू
सोचा कि यह पहले से ही है ...?
— ETHproductions
इंट डबल की आवश्यकता है?
— ब्लू
1

अल्लेटेक्स्ट्रा, श

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

मैं बस थोड़ा और अधिक चाहता हूं, केक के घटने के रूप में कम लालची हो जाता है

— शॉन एच
स्रोत
1

MyFairPlusAThird, श

#!/bin/sh
fair=$(expr $2 / $4)
myextra=$(expr $2 / 3)
want=$(expr $fair + $myextra)
echo $(($want<$2?$want:$2))
— शॉन एच
स्रोत
1

खाओ Eat, 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);

वास्तव में पसंद है, और वह केक सोचता है माध्यम है π।

— टूथब्रश
स्रोत
फिर यह केक क्यों खा रहा है? : पी
— TheNumberOne
1
@ TheNumberOne क्योंकि इसे और कुछ नहीं खिलाया जाता है :(
— टूथब्रश
2
@ TheNumberOne अब यह सोचता है कि केक Why है
— टूथब्रश
मुझे कमांड स्क्रिप्ट से बच गए उद्धरणों को हटाना था और var totalπ=process.argv[2], πLeft=process.argv[3], totalPeople=process.argv[4], peopleLeft=process.argv[5];इस काम को कंट्रोलर के साथ बनाने के लिए स्क्रिप्ट की दूसरी लाइन को फिर से लिखना था । उसे 41 बॉट्स के क्षेत्र में 3600 में से 97 मिले।
— काबिबी ४०
1

द लिटिल ऑफ द टॉप, पायथन 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)

चूंकि "सही" एल्गोरिथम बॉट्स के बीच केक को समान रूप से विभाजित करने की कोशिश करता है, हम उससे कम सिर्फ एक ज़ुल्फ़ लेने जा रहे हैं। समग्र केक के अपने पूर्ण उचित हिस्से की मांग करता है, यहां तक ​​कि बाद के दौर में भी, लेकिन उस संख्या को ऊपर की ओर छोड़ देता है क्योंकि यह इस बात पर आधारित है कि कितने लोग शेष हैं।

मैंने एक लंबे समय में पायथन में प्रोग्राम नहीं किया है , इसलिए मुझे बताएं कि क्या मेरा कोड टूट गया है ...

— AdmBorkBork
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.