चलो कुछ रीपर खेलते हैं - सबमिशन के लिए बंद

Question

नोट : इस प्रतियोगिता का विजेता जैक !!! है। कोई और सबमिशन स्वीकार नहीं किया जाएगा।

यहां इस राजा की पहाड़ी चुनौती के लिए चैट रूम है । यह मेरा पहला एक है तो मैं सुझाव के लिए खुला हूँ!

रीपर एक गेम कॉन्सेप्ट है जिसे आर्ट ऑफ़ प्रॉब्लम सॉल्विंग द्वारा विकसित किया गया है जिसमें धैर्य और लालच शामिल है। KOTH शैली प्रतियोगिता (अपने सुझावों और सुधारों के लिए @NathanMerrill और @dzaima को धन्यवाद) फिट करने के लिए खेल को संशोधित करने के बाद, यहाँ चुनौती है।

खेल निम्नलिखित के रूप में काम करता है: हमारे पास रीप के रूप में जाना जाने वाला एक मूल्य है जो किसी दिए गए हर टिक से गुणा करता है। प्रत्येक टिक के बाद, प्रत्येक बॉट में "रीपिंग" का विकल्प होता है, जिसका अर्थ है रीप के वर्तमान मूल्य को एक अंक में जोड़ना, और रीप को 1 तक कम करना।

हालाँकि, टिक की एक निश्चित संख्या है जो एक बॉट को "रीप्स" के बीच में इंतजार करना होगा, और गेम जीतने के लिए निश्चित अंकों की एक निश्चित संख्या।

काफी सरल? यहां आपके इनपुट हैं:

आई / ओ

आपको पायथन 3 में एक फ़ंक्शन लिखना है जो 3 इनपुट लेता है। पहले का selfउपयोग, कक्षा की वस्तुओं को संदर्भित करने के लिए किया जाता है (बाद में दिखाया गया है)। दूसरा है Reap, रीप का वर्तमान मूल्य जो आप कमाते हैं यदि आप "रीप" करते हैं। तीसरा है prevReap, पिछले टिक के दौरान बॉट्स की एक सूची।

अन्य वस्तुएँ जिन्हें आप अपने फ़ंक्शन में एक्सेस कर सकते हैं:

self.obj: An object for your use to store information between ticks.
self.mult: The multiplier that Reap is multiplied by each tick
self.win: The score you need to win
self.points: Your current set of points
self.waittime: The amount of ticks that you must wait between reaps during the game
self.time: The number of ticks since your last reap
self.lenBots: The number of bots (including you) in the game.
self.getRandom(): Use to produce a random number between 0 and 1.

आप चाहिए इन वस्तुओं में से किसी भी सामग्री को संपादित नहीं, के लिए छोड़कर self.obj।

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

नियम

मैं जिन मापदंडों का उपयोग कर रहा हूं winning_score=10000, वे हैं multiplier=1.6-(1.2/(1+sqrt(x))), waittime = floor(1.5*x)जहां xकोठ में बॉट की संख्या है।

• खेल तब समाप्त होता है जब कोई खिलाड़ी (या एकाधिक) विजेता स्कोर तक पहुंचता है।
• जब कई बॉट्स एक ही बार में रिप करने के लिए कहते हैं, तो उन बॉट्स को प्राथमिकता दी जाती है, जिन्होंने लंबे समय तक इंतजार किया है (संबंधों के मामले में, जिन बॉट्स ने अधिकतम समय का इंतजार किया है उन्हें रीप में अंक हासिल करने और हासिल करने की अनुमति है)
• आपके बॉट को 5 टिक्स के पार औसतन 100 से अधिक एमएस नहीं लेना चाहिए।
• यदि आप पुस्तकालयों को आयात करना चाहते हैं, तो पूछें! मैं किसी भी लाइब्रेरी को जोड़ने की कोशिश करूंगा, जिसे मैं पायथन के अपने डेस्कटॉप संस्करण पर चला सकता हूं (गणित पहले से ही आयातित है: इसे इस्तेमाल करने के लिए स्वतंत्र महसूस करें)
• KoTHs के सभी मानक कमियां, जैसे डुप्लिकेट बॉट्स, 1-अप बॉट्स, इत्यादि इसी तरह से प्रतिबंधित हैं।
• किसी भी प्रकार के यादृच्छिकता का उपयोग करने वाले किसी भी बॉट को getRandomमेरे द्वारा प्रदान किए गए फ़ंक्शन का उपयोग करना चाहिए ।

आप नीचे TIO लिंक में नियंत्रक पा सकते हैं। इसका उपयोग करने के लिए, अपने फ़ंक्शन का नाम BotListस्ट्रिंग के रूप में जोड़ें, और फिर फ़ंक्शन को कोड में जोड़ें। संशोधित multiplierबदल क्या रीप प्रत्येक टिक से गुणा किया जाता, संशोधित करने के लिए winning_scoreक्या स्कोर खेल को समाप्त करने के लिए आवश्यक है बदलने के लिए, और संशोधित waittimeकाटनेवाला के बीच प्रतीक्षा करने के लिए टिक की संख्या बदलने के लिए।

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

def Greedybot(self,Reap, prevReap):
    return 1
def Randombot(self,Reap, prevReap):
    if self.obj == None:
        self.obj=[]
    self.obj.append(prevReap)
    if self.getRandom()>0.5:
        return 1

इच्छुक लोगों के लिए, यहां 15 सबमिशन के साथ कंट्रोलर दिया गया है: इसे ऑनलाइन आज़माएं

अंतिम परिणाम

वे यहाँ अंतिम हैं! अंतिम स्टैंडिंग उत्पन्न करने के लिए मैंने किस कोड का उपयोग किया है यह देखने के लिए ऊपर दिए गए TIO लिंक को देखें। परिणाम बहुत दिलचस्प नहीं हैं। 1000 से अधिक रन मैंने अलग-अलग यादृच्छिक बीजों के साथ किए, परिणाम थे

1000 wins - Jack
0 wins - everyone else

बाउंटी विजेता जैक को बधाई !! (उर्फ @ रंजी)

Comments

मान लें कि दो बॉट्स एक ही समय में काटते हैं, और सबसे लंबे समय तक प्रतीक्षा समय जीतता है। क्या अन्य बॉट में भी इसके प्रतीक्षा समय को सक्षम किया जाएगा, क्योंकि यह वास्तव में इस दौर को दोबारा प्राप्त करने में सक्षम नहीं था, मूल रूप से अपने 'रीप' को बर्बाद कर रहा है? और क्या होता है जब दो बॉट्स एक ही समय में एक ही प्रतीक्षा समय के साथ मिलते हैं?

— केविन क्रूज़सेन

इसका उपयोग करने की अनुमति है len(BotList)?

— रेनजी

@ Renzeee Ooo ने इस बारे में नहीं सोचा था! मैं एक त्वरित संशोधन करूँगा।

— डॉन थाउजेंड

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

— केविन क्रूज़सेन

@ ऋषभ मेहता गोत्र, मैं मना करूंगा। मैंने अभी-अभी पूछा b / c मैं स्वतंत्र रूप से अन्य बॉट्स स्कोर और वेइमिट्स को ट्रैक कर रहा था ताकि उन्हें ठीक किया जा सके, और मैं आलसी हूं। :)

— त्रिगुटर्नोमेट्री

Answer 1

इंडिकिसिव ट्विची मेस

def mess(self, Reap, prevReap):
    if not hasattr(self.obj, "start"):
            self.obj.start = False
    if self.time < self.waittime:
        return 0
    if self.points + Reap >= self.win:
            return 1
    if Reap >= self.waittime / (self.lenBots + 2):
        self.obj.start = True
    if self.obj.start:
        return 1 if self.getRandom() > 0.2 else 0
    return 1 if self.getRandom() > 0.8 else 0

यह बॉट पहले सामान्य जांच करता है (क्या मैं काट सकता हूं, क्या मैं जीत सकता हूं?) और फिर से पढ़ने से पहले एक लक्ष्य मूल्य की तलाश करता है। हालाँकि, यह अनिर्णायक है, इसलिए लक्ष्य तक पहुँचने के बाद, यह आश्चर्य होता है कि यह कितना लंबा इंतजार कर सकता है और तुरंत वापस नहीं आता है। इसके अलावा, यह चिकोटी है, इसलिए यह गलती से "बटन दबाएं" और लक्ष्य से पहले काट सकता है।

मजेदार तथ्य: यह मूल रूप से है कि मैं एक इंसान के रूप में रीपर खेलता हूं।

Comments

अच्छा बॉट +1। मैं इसे थोड़ा ध्यान से देखूंगा। चैट में शामिल हों यदि आप पहले से ही नहीं हैं

— डॉन थाउजेंड

@RushabhMehta अब कम अनिर्णय के साथ; पी

— क्विंटेक

जब मैं कर सकता हूँ मैं आपके परिवर्तन जोड़ दूँगा!

— डॉन थाउजेंड

Answer 2

निशानची

एक बॉट स्पिट द्वारा ईंधन। प्रतिद्वंद्वी के कोल्डाउन और स्कोर पर नज़र रखता है। दूसरों को जीतने से रोकने का प्रयास। बहुत ज्यादा वास्तव में कभी नहीं जीतता है, लेकिन खेल को दूसरों के लिए खेलने के लिए निराशाजनक बनाता है।

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

• यदि कटाई यह जीतने का कारण बनती है, तो काटें।

• यदि कोई नहीं है = = 70% विजेता स्कोर:

  • यदि हर कोई अपने कोल्डडाउन पर है, तो अंतिम संभावित क्षण तक प्रतीक्षा करें।
  • यदि कोई अन्य व्यक्ति वर्तमान मूल्य को काटकर जीत जाएगा, और वे अभी सक्रिय हैं या अगले मोड़ पर सक्रिय होंगे, तो रीप।
  • यदि कम से कम आधे अन्य उपयोगकर्ता अपने कोल्डाउन पर हैं, तो पुनः प्रयास करें। इससे विशिष्ट विरोधियों को लक्षित करना मुश्किल हो जाता है, और इसलिए हटा दिया गया था।
  • अन्यथा, समय का 25% काट लें (अनिवार्य रूप से यह गारंटी देने के लिए कि यह बॉट SOMETIMES को काटता है, बस अगर कुछ अजीब होता है, जैसे हर कोई कई मोड़ इंतजार कर रहा है)।

• अगर कोई IS> = 70% विजेता स्कोर:

  • यदि स्निपर एक टाईब्रेकर जीत सकता है, और अगले दौर में उच्चतम स्कोरिंग प्रतिद्वंद्वी, रीप के लिए औसत रीप मान से ऊपर होगा
  • यदि उच्चतम स्कोरिंग प्रतिद्वंद्वी अगले मोड़ पर अपने cooldown छोड़ देंगे, काटना।

def Sniper(self, Reap, prevReap):
    # initialize opponents array
    if not hasattr(self.obj, "opponents"):
        self.obj.opponents = {}

    # initialize previous Reap value
    if not hasattr(self.obj, "lastReap"):
        self.obj.lastReap = 0

    # increment all stored wait times to see who will be "active" this turn
    for opponent in self.obj.opponents:
        self.obj.opponents[opponent]["time"] += 1

    # update opponents array
    for opponent in prevReap:
        # don't track yourself, since you're not an opponent
        if opponent != "Sniper":
            # initialize opponent
            if opponent not in self.obj.opponents:
                self.obj.opponents[opponent] = {"time": 0, "points": 0, "num_reaps": 0, "avg": 0}
            self.obj.opponents[opponent]["time"] = 0
            self.obj.opponents[opponent]["points"] += self.obj.lastReap
            self.obj.opponents[opponent]["num_reaps"] += 1
            self.obj.opponents[opponent]["avg"] = self.obj.opponents[opponent]["points"] / self.obj.opponents[opponent]["num_reaps"]

    # done "assigning" points for last round, update lastReap
    self.obj.lastReap = Reap

    # get current 1st place(s) (excluding yourself)
    winner = "" if len(self.obj.opponents) == 0 else max(self.obj.opponents, key=lambda opponent:self.obj.opponents[opponent]["points"])

    # you are ready now
    if self.time >= self.waittime:
        # current Reap is sufficient for you to win
        if self.points + Reap >= self.win:
            return 1

        if (
                # a 1st place exists
                winner != ''
                # if current 1st place is close to winning
                and self.obj.opponents[winner]["points"] / self.win >= .7
        ):
            if (
                    # next round's Reap value will be above opponent's average Reap
                    (Reap * self.mult >= self.obj.opponents[winner]["avg"])
                    # we have been waiting at least as long as our opponent (tiebreaker)
                    and self.time >= self.obj.opponents[winner]["time"]
            ):
                return 1

                # current 1st place opponent will be active next round
            if self.obj.opponents[winner]["time"] + 1 >= self.waittime:
                return 1

        else:
            if (
                    # everyone is waiting for their cooldown
                    all(values["time"] < self.waittime for key, values in self.obj.opponents.items())
                    # and we're tracking ALL opponents
                    and len(self.obj.opponents) == self.lenBots - 1
                    # at least one person will be ready next turn
                    and any(values["time"] + 1 >= self.waittime for key, values in self.obj.opponents.items())
            ):
                return 1

            if (
                    # opponent will be active next round
                    any( (values["time"] + 1 >= self.waittime)
                         # current Reap value would allow opponent to win
                         and (values["points"] + Reap >= self.win) for key, values in self.obj.opponents.items())
            ):
                return 1

            if (
                    # a 1st place exists
                    winner != ''
                    # current 1st place opponent will be active next round
                    and (self.obj.opponents[winner]["time"] + 1 >= self.waittime)
                    # next round's Reap value will be above their average Reap
                    and (Reap * self.mult >= self.obj.opponents[winner]["avg"])

            ):
                return 1

            # # at least half of opponents are waiting for their cooldown
            # if sum(values["time"] < self.waittime for key, values in self.obj.opponents.items()) >= (self.lenBots - 1) / 2:
            #     return 1

            # 25% of the time
            if self.getRandom() <= .25:
                return 1

    # default return: do not snipe
    return 0

ऊब

सिर्फ मनोरंजन के लिए, यह बॉट एक दोस्त द्वारा लाया गया था और वास्तव में यहां नहीं होना चाहता। जब तक वे 1-9 में एक नंबर प्राप्त नहीं करते, तब तक वे एक d16 को रोल करते हैं, फिर वे किसी भी संख्या को फिर से भरने का प्रयास करते हैं जिसमें एक नंबर चुना हुआ अंक होता है। (एक d10 की तलाश में जाने से खेल बाधित होगा, जो असभ्य है, और 0 अभी बहुत आसान है!)

def Bored(self, Reap, prevReap):
    # if this is the first round, determine your fav number
    if not hasattr(self.obj, "fav_int"):
        r = 0

        while r == 0:
            # 4 bits are required to code 1-9 (0b1001)
            for i in range(0, 4):
                # flip a coin. Puts a 1 in this bit place 50% of the time
                if self.getRandom() >= .50:
                    r += 2**i
            # if your random bit assigning has produced a number outside the range 1-9, try again
            if not (0 < r < 10):
                r = 0

        self.obj.fav_int = r

    # you are ready now
    if self.time >= self.waittime:
        # current Reap is sufficient for you to win
        if self.points + Reap >= self.win:
            return 1
        # do you like this value?
        if str(self.obj.fav_int) in str(Reap):
            return 1
        # do you like your wait time?
        if self.time % int(self.obj.fav_int) == 0:
            return 1

    # default return: do not reap
    return 0

Comments

अच्छा बॉट! +1। यह देखना दिलचस्प होगा कि यह कैसे होता है।

— डॉन थाउजेंड

मुझे लगता है कि आपको self.obj.opponents[opponent]["time"] += 1पहले फॉर-लूप और self.obj.lastReapदूसरे फॉर-लूप के अंत में उपयोग करना चाहिए । इसके अलावा, अच्छे विचार। मैं उत्सुक हूं कि यह बहुत सारे अन्य बॉट के खिलाफ कैसे काम करेगा। जब मैं बहुत लालची और यादृच्छिक बॉट का उपयोग कर रहा हूं, तो यह सिर्फ asap को काट देगा क्योंकि अधिकांश समय बॉट्स का आधा हिस्सा नहीं काट सकता है। लेकिन निश्चित रूप से वे यथार्थवादी प्रतियोगी नहीं हैं।

— रेनजी

@ ट्रिगर्नोमेट्री आपको चैट में शामिल होना चाहिए। इसके अलावा, मेरे द्वारा पोस्ट किए गए संपादन की जाँच करें। कृपया सुनिश्चित करें कि मैंने आपके बॉट में किए गए परिवर्तन सही हैं।

— डॉन थाउजेंड

Answer 3

जैक

यह एक साधारण बॉट है जिसमें 4 नियम हैं:

• जब वह कुछ भी नहीं करता है तो उसे काटें नहीं
• हमेशा काटे जब काटते हैं तो हमें जीत देते हैं
• इसके अलावा जब 3 टिकों के लिए काटे नहीं गए हों, तो काटें
• नहीं तो कुछ मत करो

मैंने मौजूदा मौजूदा बॉट्स (स्निपर, ग्रिम_प्रैपर, एवरी 50, मेस, बेटररैमैंडम, एवेगर, कुछ और) बनाम 3 टिक्स को अनुकूलित किया है।

def Jack(self, Reap, prevReap):
    if self.time < self.waittime:
        return 0
    if self.win - self.points < Reap:
        return 1
    if self.mult ** 3 <= Reap:
        return 1
    return 0

मैंने अपने पुराने समाधान (5 टिक्स) के साथ रहने की कोशिश की है, लेकिन यदि आप एक्स टिक से अधिक समय तक नहीं काटते हैं, तो फिर से काट लें और फिर गैर-रीपिंग (यानी 5, यदि स्वयं के लिए लंबे समय तक इंतजार किया गया हो) .waittime + 5, 4 टिक के लिए काटे नहीं जाने पर भी काटें)। लेकिन यह सिर्फ 5 के बजाय 4 टिक के बाद हमेशा ठीक होने में सुधार नहीं हुआ।

Answer 4

प्रत्येक 50

Reap50 से ऊपर की राशि होने पर यह बॉट्स हर बार कटेगा ।

50 क्यों?

अगर मैं यह मानता हूं कि खेल में 25 बॉट होंगे, तो इसका मतलब है कि multiplier = 1.6-(1.2/(1+sqrt(25))) = 1.4और waittime = floor(1.5*25) = 37। Reapशुरू होने के बाद से 1यह इस तरह बढ़ेगा:

Round: 1  2    3     4      5      6      7      8       9       10      11      12      13      14      15       16       17       18       19       20       etc.
Reap:  1  1.4  1.96  2.744  ~3.84  ~5.39  ~7.53  ~10.54  ~14.76  ~20.66  ~28.92  ~40.50  ~56.69  ~79.37  ~111.12  ~155.57  ~217.79  ~304.91  ~426.88  ~597.63  etc.

जैसा कि आप देख सकते हैं, यह 13 टिक के बाद 50 से ऊपर पहुंच जाता है। के बाद से Reap1 करने के लिए एक बॉट काटनेवाला हर बार रीसेट करेगा, और waittimeएक बॉट कि काटनेवाला 37, संभावना एक बॉट काटनेवाला बाद में की तुलना में जल्दी है के लिए बहुत अधिक है, विशेष रूप से उदाहरण की तरह बॉट साथ GreedyBot, जो उनके जैसे ही काटेंगे waittimeहै फिर से उपलब्ध है। पहले मैं 200 करना चाहता था जो कि 17 वीं टिक है, कुछ हद तक 37 वेटिंग टाइम टिक के बीच में है, लेकिन इस धारणा के साथ कि 25 बॉट प्ले हैं, एक बहुत अधिक संभावना है कि कोई और Reapमुझसे पहले छीन ले । इसलिए मैंने इसे 50 पर उतारा। यह अभी भी एक अच्छी गोल संख्या है, लेकिन विशेष रूप से क्योंकि यह 13 वीं टिक (25 बॉट के साथ) है, और 13 और 'रीपिंग' भी उसी 'बुरी' शैली में थोड़ा फिट है।

कोड:

कोड हंसी तुच्छ है ।।

def Every50(self, Reap, prevReap):
  return int(Reap > 50)

टिप्पणियाँ:

खेलने में बॉट की कम मात्रा के साथ यह बॉट काफी खराब है। अभी के लिए मैं इसे छोड़ दूंगा, और मैं एक बेहतर बॉट बना सकता हूं जो वास्तव में सबसे अच्छे समय की गणना कर रहा है Reap। खेलने में बॉट की एक बेहद कम मात्रा के waittimeसाथ ही बहुत कम है, इसलिए यहां तक GreedyBotकि अगर waittimeयह कम है , तो इस बॉट से काफी आसानी से जीत सकते हैं ।

उम्मीद है कि अधिक लोग बहुत अधिक बॉट जोड़ेंगे। , पी

Comments

def Every49(self, Reap, prevReap): return Reap > 49 तुम्हारी चाल।

— क्विंटेक

@ क्विंट हेच। खेल में 25 बॉट के साथ इसका मतलब यह होगा कि यह अभी भी 13 वीं टिक है और हम दोनों रीप जीतते हैं, इसलिए मुझे आपके साथ जीत साझा करने में कोई आपत्ति नहीं है। ; पी

— केविन क्रूज़सेन

आप intअसमानता के आस-पास रखना चाह सकते हैं , क्योंकि 1 वास्तविक कमान है

— डॉन थाउजेंड

@Quintec मैं उर मजाक कर रहा हूँ, लेकिन मैं 1-अप या डुप्लिकेट बॉट की अनुमति नहीं दूंगा

— डॉन थाउजेंड

@RushabhMehta मैं अक्सर पायथन में कार्यक्रम नहीं करता, इसलिए वास्तव में पहले से ही संदेह था कि क्या मुझे Trueस्पष्ट करने के लिए कलाकारों को जोड़ना चाहिए 1। यह पता लगाया कि True == 1चेक अभी भी Trueमेरे बॉट के लिए Reapersआपके nextफ़ंक्शन की सूचियों में जोड़ देगा , लेकिन मैंने सुझाव दिया कि आप वैसे भी कलाकारों को इंट में जोड़ देंगे।

— केविन क्रूज़सेन

Answer 5

Averager

def Averager(self,Reap,prevReap):
    returner = 0
    if not hasattr(self.obj,"last"):
        self.obj.last = Reap
        self.obj.total = 0
        self.obj.count = 0
        returner = 1
    else:
        if len(prevReap) > 0:
            self.obj.total += self.obj.last
            self.obj.count += 1
        self.obj.last = Reap
    if self.obj.count > 0 and Reap > self.obj.total / self.obj.count:
        returner = 1
    return returner

यह बॉट किसी भी समय रीप करने का प्रयास करता है कि वर्तमान रीप मान औसत रीपेड मूल्य से ऊपर है।

Comments

बहुत अच्छा बॉट! +1

— डॉन थाउजेंड

मैं दोनों बहुत परेशान हूं और प्रभावित हूं कि इस तरह का एक सरल एल्गोरिदम हर किसी को इतनी आसानी से हरा देता है। अच्छा काम!

— त्रिगुटर्नोमेट्री

Answer 6

ग्रिम रीपर

यह बॉट पिछले सभी रीप्स के मूल्यों के साथ-साथ प्रत्येक बॉट के इंतजार के समय का औसत चलता रहता है। यह तब दिखाई देता है जब यह अन्य बॉट्स के 3/4 से अधिक समय तक प्रतीक्षा करता है और रीप कम से कम 3/4 होता है जो अब तक देखे गए औसत रीप का आकार है। लक्ष्य बहुत अधिक आकार लेना है, कम जोखिम है।

def grim_reaper(self, Reap, prevReap):
    if self.obj == None:
        self.obj = {}
        self.obj["reaps"] = []
        self.obj["prev"] = 1
        self.obj["players"] = {i:0 for i in range(math.ceil(self.waittime / 1.5))}
    if Reap == 1 and len(prevReap) > 0:
        self.obj["reaps"].append(self.obj["prev"])
        for player in prevReap:
            self.obj["players"][player] = 0

    retvalue = 0
    if (len(self.obj["reaps"]) > 0 
         and Reap > sum(self.obj["reaps"]) / len(self.obj["reaps"]) * 3. / 4.
         and sum([self.time >= i for i in self.obj["players"].values()]) >= len(self.obj["players"].values()) * 3 / 4):
        retvalue = 1

    for player in self.obj["players"]:
        self.obj["players"][player] += 1
    self.obj["prev"] = Reap
    return retvalue

संपादित करें: कुछ शर्मनाक वाक्यविन्यास त्रुटियों को ठीक किया।

इसे ऑनलाइन आज़माएं

Comments

आप का उपयोग करना चाहिए self.obj.reapsके बजाय self.reapsऔर self.objके बजाय self.objectऔर prevReapके बजाय prevLeapऔर () के बाद जोड़ने के self.obj.players.valuesदो बार। और मुझे लगता है कि self.obj.reaps = []जब तक self.objकोई वस्तु नहीं है, तब तक काम नहीं करेगा । मुझे पूरी तरह से यकीन नहीं है कि अगर सब कुछ अभी भी इरादा के अनुसार काम करता है और अगर मैंने जो कुछ कहा है वह सब सच है, लेकिन इन परिवर्तनों के बाद और self.objजब यह अभी तक मौजूद नहीं है, तो डमी ऑब्जेक्ट का उपयोग करने के लिए , आपका कोड मेरे लिए संकलित करता है।

— रेनजी

@ZacharyColton आपको गणित आयात करने की आवश्यकता नहीं है। यह पहले से ही आयातित है

— डॉन थाउजेंड

@RushabhMehta मैं जोड़ा class Object(object):[न्यू लाइन] passशीर्ष पर और इस्तेमाल self.obj = Object()में if not hasattr(..)(अगर मैं सही ढंग से याद है)।

— रेनजी

@ रेंजी अहा आईसी

— डॉन थाउजेंड

@ZacharyCotton आपको चैट में शामिल होना चाहिए।

— डॉन थाउजेंड

Answer 7

BetterRandom

def BetterRandom(self,reap,prevReap):
    return self.getRandom()>(reap/self.mult**self.waittime)**-0.810192835

बॉट इस धारणा पर आधारित है कि रीप करने का मौका रीप के आकार के समानुपाती होना चाहिए क्योंकि एक बिंदु एक बिंदु है, कोई फर्क नहीं पड़ता जब यह मिल जाता है। हमेशा एक बहुत छोटा मौका होता है, यह व्यवहार को शोषक बनाए रखता है। पहले मैंने सोचा कि यह सीधे आनुपातिक होगा और चारों ओर होने के लिए आनुपातिकता स्थिरांक मान लिया जाएगा 1/mult^waittime(कम से कम एक बॉट नाटकों लालची मानते हुए) कुछ सिमुलेशन चलाने के बाद मैंने पाया कि यह वास्तव में इष्टतम स्थिरांक था। लेकिन बोट अभी भी बेतरतीब ढंग से बेतरतीब था, इसलिए मैंने निष्कर्ष निकाला कि संबंध सीधे आनुपातिक नहीं था और यह गणना करने के लिए एक निरंतरता जोड़ा कि संबंध क्या था। कुछ सिमुलेशन के बाद मैंने पाया कि बॉट के मेरे परीक्षण सेट के खिलाफ -1.5इष्टतम था। यह वास्तव में रिप मौका और के बीच एक व्युत्क्रमानुपाती संबंध से मेल खाती हैreap*sqrt(reap)जो आश्चर्य की बात है। इसलिए मुझे संदेह है कि यह विशिष्ट बॉट्स पर निर्भर है इसलिए इस बॉट का एक संस्करण जो कि खेलते समय k की गणना करता है बेहतर होगा। (लेकिन मुझे नहीं पता कि आपको पिछले राउंड से डेटा का उपयोग करने की अनुमति है)।

संपादित करें: मैंने स्वचालित रूप से आनुपातिकता का पता लगाने के लिए कार्यक्रम बनाया। परीक्षण सेट पर ["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"]मुझे नया मान मिला।

Comments

मैं जल्दी ही अपने बॉट का उपयोग कर कुछ नए आँकड़े जोड़ देंगे

— डॉन हजार

ऐसा लगता है (reap/self.mult**self.waittime)**-0.810192835कि हमेशा 1 से ऊपर होता है, अर्थात self.getRandom () कभी अधिक नहीं होता है।

— रेनजी

@ Fajfo आपको पिछले दौर के डेटा का उपयोग करने की भी अनुमति है। इसके self.objलिए जो है। इसका उपयोग करने के तरीके के बारे में कुछ उदाहरणों को देखने के लिए, कुछ अन्य बॉट्स देखें जो इसका उपयोग कर रहे हैं।

— डॉन थाउजेंड

Answer 8

लक्ष्य

def target(self,Reap,prevReap):
    if not hasattr(self.obj, "target_time"):
        self.obj.target_time = -1
        self.obj.targeting = False
        self.obj.target = None
    if self.obj.target_time >= 0:
        self.obj.target_time += 1

    if self.time < self.waittime:
            return 0
    if self.points + Reap >= self.win:
        return 1
    if len(prevReap) > 0:
        if not self.obj.targeting:
            self.obj.target_time = 0
            self.obj.target = prevReap[int(self.getRandom() * len(prevReap))]
            self.obj.targeting = True
    if self.waittime <= self.obj.target_time + 1:
        self.obj.targeting = False
        self.obj.target = None
        self.obj.target_time = -1
        return 1
    return 0

गड़बड़ के साथ जीतने की मेरी संभावना लगभग अब नहीं है, इसलिए जितना संभव हो उतने अन्य सभी बॉट को गड़बड़ करने का समय है! :)

यह बॉट स्नाइपर के समान कार्य करता है। जब भी कोई पढ़ता है, यह जो भी काटता है उससे एक यादृच्छिक लक्ष्य चुनता है। फिर, यह बस इंतजार करता है जब तक कि लक्ष्य लगभग फिर से काट सकता है और इसे छीन सकता है। हालाँकि, यह फ़ोकस नहीं बदलता है - एक बार जब आप चुन लिए गए और लॉक कर दिए गए, तो आप बच नहीं सकते :)

Answer 9

EveryN

मुझे लगता है कि यह समय सीमा से ठीक पहले मेरे दूसरे बॉट का समय है।

यह बॉट होगा:

• छोड़ दें जब यह अभी भी अपने अंतिम समय में प्रतीक्षा कर रहा है
• जब जीत सकते हैं तो काटें
• जब कोई कम से कम nराउंड के लिए वापस नहीं आता है, तो उसके nसाथ गणना की जाती हैn = 3 + ceil(self.waittime / self.lenBots)

कोड:

def every_n(self, Reap, prevReap):
    # Initialize obj fields
    if not hasattr(self.obj, "roundsWithoutReaps"):
        self.obj.roundsWithoutReaps = 0

    # Increase the roundsWithoutReaps if no bots reaped last round
    if len(prevReap) < 1:
        self.obj.roundsWithoutReaps += 1
    else
        self.obj.roundsWithoutReaps = 0

    # Skip if you're still in your waiting time
    if self.time < self.waittime:
        return 0
    # Reap if you can win
    if self.win - self.points < Reap:
        return 1

    # i.e. 25 bots: 3 + ceil(37 / 25) = 5
    n = 3 + math.ceil(self.waittime / self.lenBots)

    # Only reap when no bots have reaped for at least `n` rounds
    if self.obj.roundsWithoutReaps >= n:
        self.obj.roundsWithoutReaps = 0
        return 1

    return 0

मैं पायथन में बहुत बार कार्यक्रम नहीं करता, इसलिए यदि आपको कोई गलतियाँ दिखती हैं तो मुझे बताएं।

Comments

पवित्र लंबे चर नाम। (इसके अलावा, पीईपी: python.org/dev/peps/pep-0008 )

— क्विंट सेक

@ क्विंट ने 2-स्पेस इंडेंटेशन को 4 में बदल दिया; छोटा subsequentRoundsWithoutReapsकरने के लिए roundsWithoutReaps; विधि नाम के लिए अंडरस्कोर के साथ लोअरकेस का उपयोग किया; और अगर बयानों पर कोष्ठक हटा दिया। धन्यवाद।

— केविन क्रूज़सेन

कोई दिक्कत नहीं है! (तकनीकी रूप से यह राउंड_विथआउट_प्रॉप्स होना चाहिए, लेकिन यह वास्तव में कोई मुद्दा नहीं है क्योंकि यह चुनौती मिश्रित कैमिक्लस का भी उपयोग करती है इसलिए यह वास्तव में कोई फर्क नहीं पड़ता)

— क्विंटेक

@Quintec आह ठीक है। मैं prevReapऔर lenBotsऔर इस तरह के और ग्रहण किए गए चर जावा में कैमेलकेस की तरह लगते हैं। ;) ठीक है, जो भी मामला हम उपयोग करते हैं, उसे वैसे भी काम करना चाहिए। 4 इंडेंट किए गए रिक्त स्थान के बजाय 2 शायद कुछ समस्याओं का कारण होगा, इसलिए दोनों तरह से धन्यवाद।

— केविन क्रूज़सेन

Answer 10

चल रहा है: हर खुले KOTH को T4T का विस्तार करने की मेरी परियोजना।

जैसे को तैसा

def t4t(self, r, p):
    if(not hasattr(self.obj,"last")): self.obj.last = self.win
    if(p):
        self.obj.last = r
        return 0

    # The usual checks
    if self.time < self.waittime:
        return 0
    if self.points + r >= self.win:
        return 1

    if(r >= self.obj.last):
        return 1

N Tats के लिए शीर्षक

def t4nt(self, r, p):
    n = 5 # Subject to change
    if(not hasattr(self.obj,"last")): self.obj.last = [self.win]*n

    if(p):
        self.obj.last.append(r)
        self.obj.last.pop(0)
        return 0

    # The usual checks
    if(self.time < self.waittime):
        return 0
    if(self.points + r >= self.win):
        return 1

    if(r >= self.obj.last[0]):
        return 1

---

केविन

बस आपको अपने पैर की उंगलियों पर रखना है।

def kevin(just, a, joke):
    return 0

Comments

याद रखना सुनिश्चित करें, self.lastएक बात नहीं है, लेकिन आप self.obj.lastएक बात कर सकते हैं ! वैसे भी, मैं आपके सभी तीन बॉट्स को मेमेस +1 के लिए जोड़ दूंगा

— डॉन थाउजेंड

हाँ, मैं एक मूर्ख हूँ। फिक्स्ड।

— SIGSTACKFAULT

@RushabhMehta बस के माध्यम से चला गया और उन्हें वास्तव में काम किया। pls संपादित करें।

— SIGSTACKFAULT

बढ़िया है! जीसी में शामिल हों, मैं कुछ आंशिक परिणाम वहां पोस्ट करूंगा

— डॉन थाउजेंड

Answer 11

औसत जोए

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

def average_joe(self, Reap, prevReap):

    if not hasattr(self.obj, "average_turns"):
        self.obj.turns_since_reap = 1
        self.obj.total_turns = 0
        self.obj.total_reaps = 0
        return 1

    if len(prevReap) > 0:
        self.obj.total_turns = self.obj.total_turns + self.obj.turns_since_reap
        self.obj.total_reaps += 1
        self.obj.turns_since_reap = 0
    else:
        self.obj.turns_since_reap += 1

    # Don't reap if you are in cooldown
    if self.time < self.waittime:
        return 0

    # Reap if you are going to win
    if self.win - self.points < Reap:
        return 1

    # Reap if it is one turn before average
    average_turns = self.obj.total_turns / self.obj.total_reaps

    if average_turns - 1 >= self.obj.turns_since_reap:
        return 1
    else:
        return 0

Comments

मैं इसे कल में जोड़ूंगा।

— डॉन थाउजेंड

Answer 12

हार्ड कोडित

हाँ यही है।

def HardCo(self,reap,prevReap):
    return reap > 2

पिछले रीप्स पर औसत के बजाय, एक सामान्य रन पर पूर्व-परिकलित औसत का उपयोग करें। यह वैसे भी समय के साथ बेहतर नहीं होने जा रहा है।