আসুন কিছু রিপার খেলি - জমা দেওয়ার জন্য বন্ধ


13

দ্রষ্টব্য : এই প্রতিযোগিতার বিজয়ী হলেন জ্যাক !!! আর কোনও জমা গ্রহণযোগ্য হবে না।

চ্যালেঞ্জের জন্য এখানে চ্যাট রুম । এটি আমার প্রথম তাই আমি পরামর্শের জন্য উন্মুক্ত!

রিপার হ'ল আর্ট অফ প্রব্লেম সল্ভিংয়ের দ্বারা বিকাশ করা একটি গেম ধারণা যা ধৈর্য এবং লোভকে জড়িত। কোনও KOTH স্টাইলের প্রতিযোগিতায় ফিট করার জন্য গেমটি সংশোধন করার পরে (আপনার পরামর্শ এবং উন্নতির জন্য @ নাথানমারিল এবং @ ডিজাইমাকে ধন্যবাদ), এখানে চ্যালেঞ্জ is

গেমটি নিম্নলিখিত হিসাবে কাজ করে: রিপ হিসাবে আমাদের কাছে একটি মূল্য রয়েছে যা প্রতিটি ধাপে ধ্রুবক দ্বারা গুণ করে। প্রতিটি টিকের পরে, প্রতিটি বটটিতে "রিপিং" এর বিকল্প রয়েছে, যার অর্থ হ'ল কাটার বর্তমান মূল্যটি কারও স্কোরের সাথে যুক্ত করা, এবং ফসল কে হ্রাস করে 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)যেখানে xKOTH মধ্যে বট সংখ্যা।

  • গেমটি শেষ হয় যখন কোনও প্লেয়ার (বা একাধিক) বিজয়ী স্কোর এ পৌঁছায়।
  • যখন একাধিক বট একবারে কাটতে বলে, তখন যে বটগুলি দীর্ঘ অপেক্ষা করেছিল তাদের অগ্রাধিকার দেওয়া হয় (সম্পর্কের ক্ষেত্রে, যে বটগুলি সর্বাধিক সময় অপেক্ষা করেছিল তাদের সকলকে কাটতে এবং পয়েন্টগুলি পাওয়ার জন্য অনুমতি দেওয়া হয়)
  • আপনার বটটি অবশ্যই 5 টি টিকের উপরে গড়ে 100 এমএসের বেশি লাগবে না।
  • আপনি যদি গ্রন্থাগার আমদানি করতে চান, জিজ্ঞাসা করুন! আমি পাইথনের আমার ডেস্কটপ সংস্করণে যে কোনও লাইব্রেরি চালাতে পারি তা যুক্ত করার চেষ্টা করব (গণিতটি ইতিমধ্যে আমদানি করা হয়েছে: এটি ব্যবহারে নির্দ্বিধায়)
  • ডাব্লিকেট বটস, 1-আপ বটস ইত্যাদির মতো কোএইচটিএসের সমস্ত মানক লুফোলগুলি একইভাবে নিষিদ্ধ।
  • যে কোনও বট যে কোনও ধরণের এলোমেলো ব্যবহার করে তাদের অবশ্যই getRandomপ্রদত্ত ফাংশনটি ব্যবহার করতে হবে ।

আপনি নীচের টিআইও লিঙ্কে নিয়ামকটি খুঁজে পেতে পারেন। এটি ব্যবহার করতে, আপনার ফাংশনের নামটি BotListস্ট্রিং হিসাবে যুক্ত করুন এবং তারপরে কোডটিতে ফাংশন যুক্ত করুন। পরিবর্তন multiplierপরিবর্তন কি রীপ প্রতিটি টিক দ্বারা গুন করা হয়, সংশোধন করতে winning_scoreকি স্কোর খেলা শেষ করার জন্য প্রয়োজনীয় পরিবর্তন করতে এবং সংশোধন waittimeইন reaps মধ্যে অপেক্ষা করতে এঁটেল পোকা সংখ্যা পরিবর্তন।

আপনার সুবিধার জন্য, এখানে কিছু নমুনা (এবং বরং মূর্খ) বট দেওয়া হয়েছে। এর মতো বট জমা দেওয়ার অনুমতি দেওয়া হবে না। যাইহোক, তারা নিয়ন্ত্রণকারী কীভাবে কাজ করে তা প্রদর্শন করে।

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 টি জমা সহ কন্ট্রোলার এখানে রয়েছে: এটি অনলাইনে চেষ্টা করুন

শেষ ফলাফল

ওঁরা শেষ পর্যন্ত এখানে আছেন! চূড়ান্ত অবস্থানগুলি উত্পন্ন করতে আমি কোন কোড ব্যবহার করেছি তা দেখতে উপরের টিআইও লিঙ্কটি দেখুন Check ফলাফলগুলি মারাত্মক আকর্ষণীয় নয়। বিভিন্ন র্যান্ডম বীজের সাথে আমি যে 1000 রানের কাজ করেছি, তার ফলাফল ছিল

1000 wins - Jack
0 wins - everyone else

বাউন্টি বিজয়ী জ্যাককে অভিনন্দন !! (ওরফে @ রেনজি)


আসুন আমরা একই সাথে দুটি বট কাটতে পারি এবং দীর্ঘতম অপেক্ষার সময় জিততে পারে। অন্যান্য বটটিও কি তার অপেক্ষার সময়টি সক্ষম করে সত্ত্বেও মূলত এটির 'কাটা' নষ্ট করে আসলে এই রাউন্ডটি কাটাতে সক্ষম হয় নি? এবং একই অপেক্ষার সময় সহ দুটি বট একই সময়ে কাটলে কী ঘটে?
কেভিন ক্রুইজসেন

1
এটি ব্যবহারের অনুমতি দেওয়া হয় len(BotList)?
রেনজেই

1
@ রেঞ্জি ওও সে সম্পর্কে ভাবেন নি! আমি একটি দ্রুত পরিবর্তন করব।
ডন হাজার হাজার

1
@ রেঞ্জি ওহ, এটি অবশ্যই বিবেচনা করার জন্য দরকারী। আমার প্রতি 50 এর মতোই দ্বিতীয় বট তৈরি করতে পারে, তবে বটটিতে সত্যিকারের গণনা সহ, 25খেলায় বটগুলির উপর ভিত্তি করে আমার বিবরণে আমি যা করেছি তার পরিবর্তে । প্রথমে কিছুটা অপেক্ষা করবে অন্য লোকের বটগুলি দেখুন। রুশভ মেহতা , সমস্ত বট চালানো হবে এবং একটি বিজয়ী নির্ধারিত হবে তখন কি একটি সময়সীমা / চূড়ান্ত তারিখ থাকবে?
কেভিন ক্রুইজসেন

1
@ রুশভ মেহতা গোছা, আমি বিরত থাকব। আমি কেবল খ / সি-কে জিজ্ঞাসা করেছি যে আমি অন্যান্য বটগুলির স্কোর এবং অপেক্ষার সময়গুলিকে স্নাইপ করার জন্য স্বতন্ত্রভাবে অনুসরণ করছি এবং আমি অলস। :)
ট্রিগনোমেট্রি

উত্তর:


9

দ্বিধাগ্রস্থ টুইচি মেস

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

এই বটটি প্রথমে স্বাভাবিক পরীক্ষা করে নেয় (আমি কি ফসল কাটাতে পারি, আমি কী জিততে পারি?) এবং তারপরে কাটার আগে একটি লক্ষ্য মান সন্ধান করে। তবে এটি অনিবার্য, সুতরাং এটি লক্ষ্যে পৌঁছানোর পরে অবাক করে দেয় যে এটি আরও কতক্ষণ অপেক্ষা করতে পারে এবং অবিলম্বে কাটবে না। তদ্ব্যতীত, এটি চটকদার, সুতরাং এটি দুর্ঘটনাক্রমে "বোতামটি চাপুন" এবং লক্ষ্যবস্তুর আগেই কাটাতে পারে।

মজাদার ঘটনা: আমি মূলত এইভাবেই একজন মানুষ হিসাবে খালি খাই।


চমৎকার বট +1। আমি এটি কিছুটা কাছ থেকে দেখুন। আপনি ইতিমধ্যে না থাকলে চ্যাটে যোগ দিন
ডন হাজার হাজার

@ রুশভ মেহতা এখন কম সিদ্ধান্তহীনতার সাথে; পি
কুইন্টেক

আমি যখন পারব তখন আপনার পরিবর্তনগুলি যুক্ত করব!
ডন হাজার হাজার

9

স্নাইপার

তবুও একটি বট জ্বালানী। প্রতিপক্ষের কোল্ডাউন এবং স্কোরকে নজর রাখে। অন্যকে বিজয়ী করা থেকে বিরত রাখার চেষ্টা করা হয়। খুব বেশি কিছু আসলে জিততে পারে না, তবে অন্যদের হয়ে খেলতে খেলাকে হতাশ করে তোলে।

সম্পাদনা করুন:

  • যদি কাটা কাটা এটি জয়ের কারণ হয়ে দাঁড়ায় তবে কাটা কাটা।
  • যদি বিজয়ী স্কোরের কোনওটিই = = 70% না থাকে:

    • যদি প্রত্যেকে প্রত্যেকে তাদের স্বদেশে থাকে তবে ফসল কাটার শেষ সম্ভাব্য মুহুর্ত পর্যন্ত অপেক্ষা করুন।
    • অন্য কেউ যদি বর্তমান মানটি কেটে জিততে পারে এবং তারা এখন সক্রিয় হয় বা পরের বারে সক্রিয় হয়, ফসল কাটা।
    • যদি অন্য ব্যবহারকারীদের কমপক্ষে অর্ধেক তাদের কুলডাউন হয় তবে ফসল কাটার চেষ্টা করুন। এটি নির্দিষ্ট বিরোধীদের লক্ষ্য করা শক্ত করে তোলে এবং তাই সরানো হয়েছিল।
    • অন্যথায়, 25% সময় কাটা (মূলত এই বটটি প্রাকৃতিকভাবে কাটতে পারে তার গ্যারান্টি হিসাবে, কিছু অদ্ভুত কিছু ঘটলে যেমন প্রত্যেকে বেশিরভাগ বারের জন্য অপেক্ষা করছে)।
  • যদি কেউ IS> = বিজয়ী স্কোরের 70%:

    • যদি স্নিপার একটি টাইব্রেকার জিততে পারে, এবং পরবর্তী রাউন্ড সর্বোচ্চ স্কোরিং প্রতিপক্ষের জন্য গড় কাটার মানের থেকে উপরে হবে, আবার কাটা
    • সর্বাধিক স্কোরিং প্রতিপক্ষ যদি পরের দিকে মোড় নেমে যায় তবে কাটা পড়ুন।
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-তে একটি নম্বর না পাওয়া পর্যন্ত একটি ডি 16 রোল করে, তারপরে তারা কোনও সংখ্যায় নির্বাচিত অঙ্কটি রেখে যে কোনও সময় কাটার চেষ্টা করে। (ডি 10 সন্ধান করতে গিয়ে খেলাটি ব্যাহত হবে, যা অভদ্র এবং 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

চমৎকার বট! +1 টি। এটি কীভাবে হয় তা দেখতে আকর্ষণীয় হবে।
ডন হাজার হাজার

1
আমি মনে করি আপনার self.obj.opponents[opponent]["time"] += 1প্রথম লুপ এবং self.obj.lastReapদ্বিতীয়টি লুপের শেষে ব্যবহার করা উচিত । তা ছাড়া, দুর্দান্ত ধারণা। আমি কৌতূহল বোধ করি এটি কীভাবে অন্যান্য অনেক বটের বিরুদ্ধে কাজ করবে। যখন আমি প্রচুর লোভী এবং এলোমেলো বট ব্যবহার করি তখন এটি ঠিক ততটুকু ফসল কাটবে কারণ বেশিরভাগ সময়ই অর্ধেক বট কাটতে পারে না। তবে অবশ্যই এগুলি বাস্তববাদী প্রতিযোগী নয়।
রেঞ্জি

@ ট্রিগারনোমেট্রি আপনার চ্যাটটিতে যোগ দেওয়া উচিত। এছাড়াও, আমি পোস্ট করা সম্পাদনাগুলি চেক করুন। আপনার বটগুলিতে আমি যে পরিবর্তনগুলি করেছি তা সঠিক কিনা তা নিশ্চিত হন।
ডন হাজার হাজার

7

নাবিক

এটি 4 টি নিয়ম সহ একটি সহজ বট:

  • যখন কিছুই না করে তখন ফসল কাটাবেন না
  • ফসল কাটা যখন সর্বদা কাটা আমাদের জিততে দেয়
  • 3 টি টিকিটের জন্য যখন কাটা হয়নি তখনও কাটা পড়ুন ap
  • নাহলে কিছুই করবেন না

আমি বিদ্যমান বিদ্যমান বটগুলির বিপরীতে 3 টি টিকগুলি অপ্টিমাইজ করেছি (স্নিপার, গ্রিম_রিপার, Every50, মেস, বেটারর্যান্ডম, অ্যাভারেজার, আরও কিছু)।

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, যদি নিজের চেয়ে দীর্ঘ অপেক্ষা করা হয়) .ওয়েটটাইম + 5, 4 টি টিকিটের জন্য পুনরায় কাটা না হলে ফসল কাটাও)। তবে এটি 5 এর পরিবর্তে 4 টি টিকের পরে সর্বদা ফসল কাটাতে উন্নত হয়নি।


5

প্রতি 50

এই বটগুলি যখনই Reapপরিমাণ 50 এর উপরে থাকে প্রতিবার কাটবে ।

কেন 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 একটি বট ইন reaps প্রত্যেক সময় পুনরায় সেট করবে, এবং waittimeএকটি বট যে ইন reaps 37, সম্ভাবনা একটি বট ইন reaps পরে থেকে এখন জন্য অত্যন্ত উচ্চ, বিশেষত উদাহরণ অনুরূপ বট সঙ্গে GreedyBot, যা তাদের যত তাড়াতাড়ি ফসল কাটবে waittimeহয় আবার উপলব্ধ। প্রথমে আমি 200 টি করতে চেয়েছিলাম যা 17 ম টিক, কিছুটা মাঝখানে 37 ওয়েটিং টাইম টিকের মাঝে, তবে অনুমানের সাথে সেখানে 25 বট খেলছে সেখানে Reapআমার সামনে অন্য কেউ ছিনিয়ে নেওয়ার বেশ উচ্চ সম্ভাবনা রয়েছে । সুতরাং আমি এটিকে 50 এ নামিয়েছি It's এটি এখনও একটি দুর্দান্ত গোলাকার সংখ্যা, তবে বিশেষত কারণ এটি 13 তম টিক (25 বট সহ), এবং 13 এবং 'ফসল কাটা'ও একই' দুষ্ট 'ধারায় কিছুটা মাপসই।

কোড:

কোডটি হাস্যকর তুচ্ছ ..

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

মন্তব্য:

এই বটটি খেলায় কম পরিমাণে বট নিয়ে খুব খারাপ। আপাতত আমি এটি ছেড়ে যাব এবং আমি সম্ভবত সবচেয়ে ভাল সময় গণনা করে আরও ভাল বট তৈরি করতে পারি Reap। খেলায় বটগুলির একটি অত্যন্ত কম পরিমাণের সাথে waittimeঅবশ্যই অনেক কম, সুতরাং এমনকি GreedyBotযদি waittimeযথেষ্ট পরিমাণে কম হয় তবে এই বট থেকে খুব সহজেই জয়লাভ করতে পারে ।

আশা করি আরও বেশি লোক বট যোগ করবে। ; p &


def Every49(self, Reap, prevReap): return Reap > 49 তোমার চাল.
কুইন্টেক

@ কুইন্টেক হেহে 25 টি বট খেলুন এটির অর্থ এটি এখনও 13 তম টিক এবং আমরা দুজনেই ফসল জিতেছি, তাই লওল, আপনার সাথে বিজয় ভাগ করে নিতে আমার আপত্তি নেই। ; পি
কেভিন ক্রুইজসেন

আপনি intএই বৈষম্যকে ঘিরে রাখতে চাইতে পারেন , যেহেতু 1 হ'ল আসল আদেশ
ডন হাজার হাজার

@ কুইন্টেক আমি আপনার মজা করার বিষয়ে সচেতন, তবে আমি 1-আপ বা সদৃশ বটগুলিকে অনুমতি দেব না
ডন হাজার হাজার

@ রশভমহেতা আমি পাইথনে খুব ঘন ঘন প্রোগ্রাম করি না, তাই ইতিমধ্যে সন্দেহ ছিল যে আমার Trueস্পষ্ট করে দেওয়ার জন্য আমার অভিনেতাকে যুক্ত করা উচিত কিনা 1। টানা True == 1চেকটি এখনও Trueআমার বটকে Reapersআপনার nextফাংশনটির তালিকাগুলিতে যুক্ত করে ফিরিয়ে আনবে , তবে আপনার পরামর্শ অনুসারে আমি কাস্টটি যুক্ত করেছি।
কেভিন ক্রুইজসেন

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

এই বটটি যে কোনও সময় শস্যের গড় কাটাতে গড় পড়ার চেষ্টা করে Re


খুব সুন্দর বট! +1
ডন হাজার হাজার

আমি দু'জনেই অত্যন্ত বিরক্ত এবং মুগ্ধ হয়েছি যে এই জাতীয় একটি সাধারণ অ্যালগরিদম এত হস্তে প্রত্যেককে মারধর করে। দারূন কাজ!
ট্রিগারনমেট্রি

3

গ্রিম রিপার

এই বটটি পূর্ববর্তী সমস্ত কাটাগুলির মানগুলির পাশাপাশি চলমান প্রতিটি বট অপেক্ষা করার সময় চলমান গড় রাখে। এটি যখন অন্য বটগুলির 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

সম্পাদনা: কিছু বিব্রতকর সিনট্যাক্স ত্রুটি স্থির করে।

অনলাইনে চেষ্টা করুন


1
আপনার self.obj.reapsপরিবর্তে self.reapsএবং self.objপরিবর্তে এবং পরিবর্তে self.objectএবং এর prevReapপরিবর্তে দুটি ব্যবহার করা উচিত prevLeap() self.obj.players.values। এবং আমি মনে করি কোনও জিনিস self.obj.reaps = []না হলে কাজ করবে না self.obj। আমি পুরোপুরি নিশ্চিত নই যে সবকিছু তখনও উদ্দেশ্য হিসাবে কাজ করে এবং যদি আমি যা বলেছিলাম সবগুলি সত্য হয় তবে এই পরিবর্তনগুলি পরে এবং self.objযখন এটি বিদ্যমান না তখন একটি ডামি অবজেক্ট ব্যবহার করার পরে আপনার কোডটি আমার জন্য সংকলন করে।
রেনজি

@ জাচারি কলটন আপনার গাণিতিক আমদানি করতে হবে না। এটি ইতিমধ্যে আমদানি করা হয়েছে
ডন হাজার হাজার

@ রুশবেহহতা আমি উপরে class Object(object):[নিউলাইন] যুক্ত করেছি এবং এতে (যদি আমি সঠিকভাবে মনে করি) ব্যবহার করি। passself.obj = Object()if not hasattr(..)
রেনজি

@ রেনজি আহা আইসি
ডন হাজার হাজার

নিবন্ধন করুন
ডন হাজার হাজার

3

BetterRandom

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

বটটি এই ধারণার উপর ভিত্তি করে তৈরি করা হয় যে ফসল কাটার সুযোগটি কাটার আকারের সমানুপাতিক হওয়া উচিত কারণ একটি বিন্দু একটি পয়েন্ট, এটি যখন অর্জিত হয় তা বিবেচনা করে না। ফসল কাটার খুব সামান্য সুযোগ আছে, এটি আচরণকে কাজে লাগিয়ে রাখে। প্রথমে আমি ভেবেছিলাম যে এটি সরাসরি আনুপাতিক হবে এবং অনুপাতটি স্থির হয়ে উঠবে 1/mult^waittime(কিছুটা সিমুলেশন চালানোর পরে কমপক্ষে এক বট লোভী খায় এমন সর্বাধিক কাট) আমি দেখতে পেলাম যে এটি সত্যই অনুকূল ধ্রুবক ছিল। তবে বটটি এখনও র‌্যান্ডমকে ছাড়িয়ে গেছে তাই আমি সিদ্ধান্তে পৌঁছেছি যে সম্পর্কটি সরাসরি সমানুপাতিক নয় এবং সম্পর্কটি কী তা গণনা করার জন্য একটি ধ্রুবক যুক্ত করেছিলাম। কিছু সিমুলেশন পরে আমি দেখতে পেলাম যে আমার পরীক্ষার বটের বিরুদ্ধে সেটটি -1.5সর্বোত্তম ছিল। এটি আসলে ফসল সুযোগ এবং এর মধ্যে একটি বিপরীতমুখী আনুপাতিক সম্পর্কের সাথে মিলে যায়reap*sqrt(reap)যা অবাক করে দেয়। সুতরাং আমি সন্দেহ করি এটি সুনির্দিষ্ট বটের উপর নির্ভর করে তাই এই বটের এমন একটি সংস্করণ যা খেলে কে কে গণনা করা ভাল। (তবে আপনাকে আগের রাউন্ড থেকে ডেটা ব্যবহার করার অনুমতি দেওয়া হয়েছে কিনা তা আমি জানি না)।

সম্পাদনা: স্বয়ংক্রিয়ভাবে ধরণের অনুপাতের সন্ধান করার জন্য আমি প্রোগ্রাম তৈরি করেছি। পরীক্ষার সেটে ["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"]আমি নতুন মানটি পেয়েছি।


আমি শীঘ্রই আপনার বট ব্যবহার করে কিছু নতুন পরিসংখ্যান যুক্ত করব
ডন হাজার হাজার

1
দেখে মনে হচ্ছে (reap/self.mult**self.waittime)**-0.810192835এটি সর্বদা 1 এর উপরে থাকে, অর্থাত্ self.getRandom () কখনই উচ্চতর হয় না।
রেনজেই

@fejfo আপনিও আগের রাউন্ডের ডেটা ব্যবহারের অনুমতি পেয়েছেন। এটা কি self.objজন্য। এটি কীভাবে ব্যবহার করতে হয় তার কয়েকটি উদাহরণ দেখতে, এটি ব্যবহার করছে এমন আরও কিছু বট দেখুন।
ডন হাজার হাজার

3

লক্ষ্য

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

আমার জগাখিচির সাথে জয়ের সম্ভাবনা এখন প্রায় কোনওটাই নেই, তাই অন্য সমস্ত বটগুলিকে যতটা সম্ভব সম্ভব উপায়ে গুঁড়িয়ে দেওয়ার সময়! :)

এই বট স্নিপারের মতোই কাজ করে। যখনই কেউ ফসল কাটেন, তবে যে কেউ শস্য কাটবে তার কাছ থেকে এটি একটি এলোমেলো লক্ষ্য অর্জন করে। তারপরে, লক্ষ্যটি প্রায় কাটা এবং এটি স্নাইপ না করা পর্যন্ত এটি কেবল অপেক্ষা করে। যাইহোক, এটি ফোকাস পরিবর্তন করে না - একবার আপনাকে চয়ন এবং লক করা হয়ে গেলে আপনি পালাতে পারবেন না :)


2

EveryN

আমার ধারণা, সময় শেষ হওয়ার ঠিক আগে আমার দ্বিতীয় বটের সময় এসেছে।

এই বট করবে:

  • এটি এখনও শেষ কাটার জন্য অপেক্ষা করার সময় এড়িয়ে যান ip
  • এটি যখন জিততে পারে তখন কাটুন
  • কেউ যখন কমপক্ষে 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

আমি পাইথনে খুব ঘন ঘন প্রোগ্রাম করি না, তাই যদি কোনও ভুল দেখতে পান তবে আমাকে জানান।


পবিত্র দীর্ঘ পরিবর্তনশীল নাম। (এছাড়াও, পিইপি: পাইথন.আর / দেব / পেপস / পেপ-0008 )
কুইন্টেক

@ কুইনটেক 2-স্পেস ইন্ডেন্টেশনটি 4 এ পরিবর্তন করেছে; সংক্ষিপ্ত subsequentRoundsWithoutReapsকরা roundsWithoutReaps; পদ্ধতির নামের জন্য আন্ডারস্কোর সহ ছোট ছোট ব্যবহৃত; এবং if-বিবৃতিগুলিতে প্রথম বন্ধনী সরানো হয়েছে। ধন্যবাদ।
কেভিন ক্রুইজসেন

সমস্যা নেই! (প্রযুক্তিগতভাবে এটি গোলাকার_বিহীন_আপনাগুলি হওয়া উচিত, তবে এটি আসলেই একটি সমস্যা নয় কারণ এই চ্যালেঞ্জটি মিশ্র ক্যামেলকেসও ব্যবহার করে তাই এটি কোনও গুরুত্বপূর্ণ নয়)
Quintec

@ কুইন্টেক আহ ঠিক আছে আমি দিকে তাকিয়ে prevReapএবং lenBotsএবং অমুক অধিকৃত ভেরিয়েবল জাভা মত ক্যামেলকেস হয়। ;) আহা ভাল, আমরা যে কোনও ক্ষেত্রেই ব্যবহার করি না কেন এটি যেকোনভাবে কাজ করা উচিত। 4 টি ইন্ডেন্ট করা জায়গাগুলির পরিবর্তে 2 সম্ভবত কিছু সমস্যা তৈরি করতে পারে তবে তাই কোনওভাবেই ধন্যবাদ।
কেভিন ক্রুইজসেন

2

চলমান: প্রতিটি প্রারম্ভিক 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

এন ট্যাটসের জন্য তৃতীয়

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

মনে রাখবেন তা নিশ্চিত করুন, self.lastকোনও জিনিস নয়, তবে আপনি self.obj.lastএকটি জিনিস তৈরি করতে পারেন ! যাইহোক, আমি মেমস +1 এর জন্য আপনার তিনটি বট যোগ করব
ডন হাজার হাজার

হ্যাঁ, আমি একজন বোকা। সংশোধন করা হয়েছে।
সাইনস্ট্যাকএফএল্ট

@ রুশভ মেহতা সবেমাত্র এগুলি দিয়েছিল এবং এগুলিকে বাস্তবে কাজ করে তুলেছে। pls সম্পাদনা করুন।
সাইনস্ট্যাকএফএল্ট

ভাল লাগছে! জিসিতে যোগ দিন, আমি সেখানে কিছু আংশিক ফলাফল পোস্ট করব
ডন হাজার হাজার

1

গড় জো

আমি অ্যাভারেজার দ্বারা অনুপ্রাণিত হয়ে একটি বট তৈরি করেছি যা গণনা করে গড়ে যে কেউ কেউ কাটার আগে তার কতটা মোড় নেয় এবং তার আগে একটি পালা কাটার চেষ্টা করে।

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

আমি আগামীকাল এ যোগ করব।
ডন হাজার হাজার

1

হার্ডকোডেড

হ্যাঁ, তাই

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

অতীত শস্যের গড় গড়ের পরিবর্তে, একটি সাধারণ রানে প্রাক-গণনা করা গড় ব্যবহার করুন। এটি যাইহোক সময়ের সাথে ভাল হতে চলেছে না।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.