19

চ্যালেঞ্জের অবস্থা: উন্মুক্ত

মন্তব্য করুন, একটি জনসংযোগ খুলুন, বা অন্যথায় যদি আমি আপনার বটটি মিস করছি তবে আমাকে চিত্কার করুন।

কারাগারের দ্বিধা ... তিনটি পছন্দ সহ। পাগল, হাহ?

এখানে আমাদের পেওফ ম্যাট্রিক্স। বাম দিকে খেলোয়াড় এ, শীর্ষে বি

A,B| C | N | D
---|---|---|---
 C |3,3|4,1|0,5
 N |1,4|2,2|3,2
 D |5,0|2,3|1,1

পেওফ ম্যাট্রিক্সটি ইঞ্জিনিয়ারড যাতে উভয় খেলোয়াড়ের পক্ষে সর্বদা সহযোগিতা করা সবচেয়ে ভাল তবে আপনি নিরপেক্ষ বা ডিফেকশন বেছে নিয়ে (সাধারণত) অর্জন করতে পারেন।

এখানে কিছু (প্রতিযোগিতামূলক) উদাহরণ বট।

# turns out if you don't actually have to implement __init__(). TIL!

class AllC:
    def round(self, _): return "C"
class AllN:
    def round(self, _): return "N"
class AllD:
    def round(self, _): return "D"
class RandomBot:
    def round(self, _): return random.choice(["C", "N", "D"])

# Actually using an identically-behaving "FastGrudger".
class Grudger:
    def __init__(self):
        self.history = []
    def round(self, last):
        if(last):
            self.history.append(last)
            if(self.history.count("D") > 0):
                return "D"
        return "C"

class TitForTat:
    def round(self, last):
        if(last == "D"):
            return "D"
        return "C"

আপনার বটটি পাইথন 3 শ্রেণি। প্রতিটি গেমের জন্য একটি নতুন উদাহরণ তৈরি করা হয়, এবং round()প্রতিদ্বন্দ্বী বলা হয়, আপনার প্রতিপক্ষের শেষ রাউন্ড থেকে পছন্দ (বা কোনও কিছুই নয়, যদি এটি প্রথম রাউন্ড হয়)

এক মাসের মতো বিজয়ীর জন্য একটি 50 টি রেপ বন্টি রয়েছে।

সুনির্দিষ্ট

প্রতিটি বট নিজেই, [REDACTED] রাউন্ডে প্রতিটি অন্যান্য বট খেলেন (1v1)।
স্ট্যান্ডার্ড লুফোলগুলি অনুমোদিত নয়।
আপনার ক্লাসের বাইরে বা অন্য আন্ডারহেনড শেেননিগাইনের বাইরে কোনও কিছুর সাথে গোলযোগ নেই।
আপনি পাঁচটি পর্যন্ত বট জমা দিতে পারেন।
হ্যাঁ, আপনি হ্যান্ডশেক বাস্তবায়ন করতে পারেন।
কোন ব্যতীত অন্য প্রতিক্রিয়া C, Nঅথবা Dচুপটি হিসাবে নিয়ে যাওয়া হবে N।
তারা খেলা প্রতিটি গেমের প্রতিটি বটের পয়েন্ট মোট এবং তুলনা করা হবে।

নিয়ামক

পরীক্ষা করে দেখুন!

অন্যান্য ভাষাসমূহ

কারওর প্রয়োজন হলে আমি একটি এপিআই একসাথে ফেলে দেব।

স্কোর: 2018-11-27

27 bots, 729 games.

name            | avg. score/round
----------------|-------------------
PatternFinder   | 3.152
DirichletDice2  | 3.019
EvaluaterBot    | 2.971
Ensemble        | 2.800
DirichletDice   | 2.763
Shifting        | 2.737
FastGrudger     | 2.632
Nash2           | 2.574
HistoricAverage | 2.552
LastOptimalBot  | 2.532
Number6         | 2.531
HandshakeBot    | 2.458
OldTitForTat    | 2.411
WeightedAverage | 2.403
TitForTat       | 2.328
AllD            | 2.272
Tetragram       | 2.256
Nash            | 2.193
Jade            | 2.186
Useless         | 2.140
RandomBot       | 2.018
CopyCat         | 1.902
TatForTit       | 1.891
NeverCOOP       | 1.710
AllC            | 1.565
AllN            | 1.446
Kevin           | 1.322

king-of-the-hill python

— SIGSTACKFAULT
সূত্র

1

একে অপরের বিরুদ্ধে কীভাবে বট করা হয়? আমি গ্রুডারের কাছ থেকে পেয়েছি যে একে অপরের বিপরীতে / সাথে সর্বদা দুটি বট থাকে এবং শত্রুর শেষ পছন্দটি বটটিতে দেওয়া হয়। কত রাউন্ড খেলা হয়? এবং একটি গেমের জন্য: কেবল ফলাফল গণনা করা হয় (অর্থাত্ কে জিতেছে) বা পয়েন্টগুলিও?

— কালো আউল কাই

1

আপনি যদি এই ভাষা-অজ্ঞাত বা কমপক্ষে আরও বিস্তৃত করেন তবে আপনি আরও এন্ট্রি পাবেন। আপনার কাছে একটি মোড়ক পাইথন ক্লাস থাকতে পারে যা একটি প্রক্রিয়া তৈরি করে এবং পাঠ্য প্রতিক্রিয়াগুলি ফিরে পেতে এটি পাঠ্য কমান্ডগুলি প্রেরণ করে।

— স্পার

1

সম্পন্ন. এটি এক মাসের মতো স্যান্ডবক্সে ছিল!

— সিগস্ট্যাকফোল্ট

2

আপনি main.py অধিকাংশ মোড়ানো তাহলে while len(botlist) > 1:সঙ্গে botlist.remove(lowest_scoring_bot)লুপ নীচে, আপনি আকর্ষণীয় ফলাফল সঙ্গে একটি বর্জন টুর্নামেন্ট পেতে।

— স্পার

1

এই দিনটির আর একটি সংস্করণ কেবল শেষ পদক্ষেপের চেয়ে পুরো ইন্টারঅ্যাকশন ইতিহাসটি পাস করবে। এটি ব্যবহারকারীর কোডটি কিছুটা সহজ করার পরেও এটি খুব বেশি পরিবর্তন করে না। তবে এটি এক্সটেনশনের অনুমতি দেবে যেমন শোরগোলের যোগাযোগের চ্যানেলগুলি যা সময়ের সাথে সাথে স্পষ্ট করে: "সত্যই, একটি ডি, যদিও আমি একটানা চারবার সি বলেছি? না, আমি ডি বলিনি; আপনি আমাকে কী নেবেন? "ওহ, দুঃখিত, আমরা কি সেই রাউন্ডটি ভুলে যেতে পারি?"

— স্কট স্যয়েট

10

EvaluaterBot

class EvaluaterBot:
    def __init__(self):
        self.c2i = {"C":0, "N":1, "D":2}
        self.i2c = {0:"C", 1:"N", 2:"D"}
        self.history = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
        self.last = [None, None]

    def round(self, last):
        if self.last[0] == None:
            ret = 2
        else:
            # Input the latest enemy action (the reaction to my action 2 rounds ago)
            # into the history
            self.history[self.last[0]][self.c2i[last]] += 1
            # The enemy will react to the last action I did
            prediction,_ = max(enumerate(self.history[self.last[1]]), key=lambda l:l[1])
            ret = (prediction - 1) % 3
        self.last = [self.last[1], ret]
        return self.i2c[ret]

পূর্ববর্তী জমা দেওয়া সমস্ত বটের বিরুদ্ধে জয় (সম্ভবত) এলোমেলো বট বাদে (তবে এটির একটি সুবিধা হতে পারে, কারণ এটি একটি ড্রতে ডি গ্রহণ করে এবং ডিটি সর্বোত্তম হওয়া উচিত) এবং তাদের বিরুদ্ধে ধ্রুবক ড্র করে plays

— কালো পেঁচা কাই
সূত্র

হ্যাঁ, সব কিছু মারছে।

— সিগস্ট্যাকফুল্ট

স্ক্র্যাচ করুন যে, প্যাটার্নফাইন্ডার এটি কিছুটা মারবে।

— সিগস্ট্যাকফুল্ট

7

NashEquilibrium

এই বট কলেজটিতে একটি গেম থিওরি ক্লাস নিয়েছে তবে অলস ছিল এবং যে ক্লাসে তারা পুনরাবৃত্ত গেমগুলি কভার করেছিল সেখানে যায় নি। সুতরাং তিনি কেবল একক খেলায় মিশ্র ন্যাশ ভারসাম্য খেলেন। 1/5 2/5 2/5 দেখা যাচ্ছে পে-অফের জন্য মিশ্র NE।

class NashEquilibrium:
    def round(self, _):
        a = random.random()
        if a <= 0.2:
            return "C"
        elif a <= 0.6:
            return "N"
        else:
            return "D"

কনস্ট্যান্ট অ্যাবিজিং ন্যাশ ভারসাম্যহীনতা

এই বটটি তার অলস ভাইয়ের কাছ থেকে দু'একটি পাঠ গ্রহণ করেছিল। তার অলস ভাইয়ের সমস্যাটি হ'ল তিনি স্থির কৌশলগুলির সদ্ব্যবহার করেন নি। এই সংস্করণটি পরীক্ষা করে যদি প্রতিপক্ষ কোনও ধ্রুবক খেলোয়াড় বা টাইটফোর্যাট হয় এবং তদনুসারে খেলে, অন্যথায় এটি নিয়মিত ন্যাশ ভারসাম্য খেলে।

এটি কেবলমাত্র নিম্নচাপ যে এটি নিজের বিরুদ্ধে খেলে প্রতি গড় ২.২ পয়েন্ট।

class NashEquilibrium2:

    def __init__(self):
        self.opphistory = [None, None, None]
        self.titfortatcounter = 0
        self.titfortatflag = 0
        self.mylast = "C"
        self.constantflag = 0
        self.myret = "C"

    def round(self, last):
        self.opphistory.pop(0)
        self.opphistory.append(last)

        # check if its a constant bot, if so exploit
        if self.opphistory.count(self.opphistory[0]) == 3:
            self.constantflag = 1
            if last == "C":
                 self.myret = "D"
            elif last == "N":
                 self.myret = "C"
            elif last == "D":
                 self.myret = "N"

        # check if its a titfortat bot, if so exploit
        # give it 2 chances to see if its titfortat as it might happen randomly
        if self.mylast == "D" and last == "D":
            self.titfortatcounter = self.titfortatcounter + 1

        if self.mylast == "D" and last!= "D":
            self.titfortatcounter = 0

        if self.titfortatcounter >= 3:
            self.titfortatflag = 1

        if self.titfortatflag == 1:
            if last == "C":
                 self.myret = "D"
            elif last == "D":
                 self.myret = "N"    
            elif last == "N":
                # tit for tat doesn't return N, we made a mistake somewhere
                 self.titfortatflag = 0
                 self.titfortatcounter = 0

        # else play the single game nash equilibrium
        if self.constantflag == 0 and self.titfortatflag == 0:
            a = random.random()
            if a <= 0.2:
                self.myret = "C"
            elif a <= 0.6:
                self.myret = "N"
            else:
                self.myret = "D"


        self.mylast = self.myret
        return self.myret

— Ofya
সূত্র

1

ন্যাশএকুইলিব্রিয়াম.গ্রাউন্ডে এটি ব্যবহার না করা সত্ত্বেও তর্কগুলি নেওয়া দরকার, যাতে প্রত্যাশিত ফাংশন প্রোটোটাইপটি মাপসই হয়।

— রায়

আপনাকে এটি সংশোধন করার জন্য ধন্যবাদ

— অফিয়া

অল্প সংক্ষিপ্ত:

class NashEquilibrium:     def round(self, _):         a = random.random()         for k, v in [(0.2, "C"), (0.6, "N"), (1, "D")]:             if a <= k:                 return v

— রবার্ট গ্রান্ট

7

TatForTit

class TatForTit:
    def round(self, last):
        if(last == "C"):
            return "N"
        return "D"

এই বোটটি ডিএনডিএনকে বিকল্প হিসাবে বেছে নেবে যখন টিটোফর্যাটটি সিডিসিডি বিকল্প হিসাবে, যদি আমি পরিশোধের ম্যাট্রিক্সটি সঠিকভাবে পড়ে থাকে তবে রাউন্ডে গড়ে 3 পয়েন্টের নিখুঁত লাভের জন্য। আমি মনে করি এটি টাইটফোর্ডের বিরুদ্ধে সর্বোত্তম হতে পারে। স্পষ্টতই এটি একটি নন-টিএফটি প্রতিপক্ষ সনাক্ত করতে এবং অন্যান্য কৌশল অবলম্বন করার জন্য উন্নত হতে পারে তবে আমি কেবল আসল অনুগ্রহের জন্য লক্ষ্য রেখেছিলাম।

— Sparr
সূত্র

6

PatternFinder

class PatternFinder:
    def __init__(self):
        import collections
        self.size = 10
        self.moves = [None]
        self.other = []
        self.patterns = collections.defaultdict(list)
        self.counter_moves = {"C":"D", "N":"C", "D":"N"}
        self.initial_move = "D"
        self.pattern_length_exponent = 1
        self.pattern_age_exponent = 1
        self.debug = False
    def round(self, last):
        self.other.append(last)
        best_pattern_match = None
        best_pattern_score = None
        best_pattern_response = None
        self.debug and print("match so far:",tuple(zip(self.moves,self.other)))
        for turn in range(max(0,len(self.moves)-self.size),len(self.moves)):
            # record patterns ending with the move that just happened
            pattern_full = tuple(zip(self.moves[turn:],self.other[turn:]))
            if len(pattern_full) > 1:
                pattern_trunc = pattern_full[:-1]
                pattern_trunc_result = pattern_full[-1][1]
                self.patterns[pattern_trunc].append([pattern_trunc_result,len(self.moves)-1])
            if pattern_full in self.patterns:
                # we've seen this pattern at least once before
                self.debug and print("I've seen",pattern_full,"before:",self.patterns[pattern_full])
                for [response,turn_num] in self.patterns[pattern_full]:
                    score = len(pattern_full) ** self.pattern_length_exponent / (len(self.moves) - turn_num) ** self.pattern_age_exponent
                    if best_pattern_score == None or score > best_pattern_score:
                        best_pattern_match = pattern_full
                        best_pattern_score = score
                        best_pattern_response = response
                    # this could be much smarter about aggregating previous responses
        if best_pattern_response:
            move = self.counter_moves[best_pattern_response]
        else:
            # fall back to playing nice
            move = "C"
        self.moves.append(move)
        self.debug and print("I choose",move)
        return move

এই বট সাম্প্রতিক গেম স্টেটের পূর্ববর্তী ঘটনাগুলির সন্ধান করে যাতে প্রতিপক্ষ কীভাবে সেই ঘটনাগুলিতে প্রতিক্রিয়া জানায়, দীর্ঘ প্যাটার্ন ম্যাচ এবং আরও সাম্প্রতিক ম্যাচের জন্য অগ্রাধিকার দেয়, তারপরে এই পদক্ষেপটি খেলবে যা প্রতিপক্ষের পূর্বাভাসের পদক্ষেপকে "পরাজিত" করবে। এটি ট্র্যাক করে রাখে এমন সমস্ত ডেটা সহ এটি আরও চৌকস হওয়ার জন্য অনেক জায়গা রয়েছে তবে আমি এটিতে কাজ করার জন্য সময়সীমা ছাড়িয়ে গেলাম।

— Sparr
সূত্র

আপনি যখন সময় পাবেন, মন তাকে একটি অপটিমাইজেশন পাস দেবেন? এটি সহজেই সবচেয়ে বড় সময়-সিংক।

— সিগস্ট্যাকফুল্ট

2

@ ব্ল্যাকসিলভার আমি সর্বাধিক প্যাটার্নের দৈর্ঘ্য ১০০ থেকে কমিয়ে ১০ এ নামিয়েছি এখনই যদি আপনি <200 রাউন্ড চালাচ্ছেন তবে এটি এখনই তাত্ক্ষণিকভাবে চালানো উচিত

— স্পার

1

সম্ভবত একটি উচ্চ যৌগিক সংখ্যা ব্যবহার করে (অর্থাত, 12) আরও ভাল স্কোর করতে পারে?

— সিগস্ট্যাকফোল্ট

5

জেড

class Jade:
    def __init__(self):
        self.dRate = 0.001
        self.nRate = 0.003

    def round(self, last):
        if last == 'D':
            self.dRate *= 1.1
            self.nRate *= 1.2
        elif last == 'N':
            self.dRate *= 1.03
            self.nRate *= 1.05
        self.dRate = min(self.dRate, 1)
        self.nRate = min(self.nRate, 1)

        x = random.random()
        if x > (1 - self.dRate):
            return 'D'
        elif x > (1 - self.nRate):
            return 'N'
        else:
            return 'C'

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

5

আঁসাঁব্ল

এটি সম্পর্কিত মডেলগুলির একটি জুড়ি চালায়। পৃথক মডেলগুলি ইতিহাসের বিভিন্ন পরিমাণ বিবেচনা করে এবং হয় সর্বদা এমন পদক্ষেপ বেছে নেওয়ার বিকল্প রয়েছে যা প্রত্যাশিত পরিশোধের পার্থক্যটিকে অনুকূল করবে, বা এলোমেলোভাবে প্রত্যাশিত পরিশোধের পার্থক্যের অনুপাতে কোনও পদক্ষেপ নির্বাচন করবে।

জমায়েতের প্রতিটি সদস্য তার পছন্দের পদক্ষেপে ভোট দেয়। প্রতিপক্ষের চেয়ে তারা কত বেশি জিতেছে তার সমান সংখ্যক ভোট তারা পায় (যার অর্থ ভয়ানক মডেলগুলি নেতিবাচক ভোট পাবে)। যে কোনও পদক্ষেপে ভোটে জয়লাভ করে তা নির্বাচন করা হয়।

(তাদের সম্ভবত প্রতিটি ভোটের পক্ষে তাদের অনুপাতের পরিমাণ অনুসারে তাদের ভোটগুলি ভাগ করা উচিত, তবে আমি এখনই এটি করার পক্ষে যথেষ্ট চিন্তা করি না।)

এটি এভালুয়েটারবট এবং প্যাটার্নফাইন্ডার ব্যতীত পোস্ট করা সমস্ত কিছুকে হারাতে পারে। (এক-এক, এটি ইভালুয়েটারবটকে পরাজিত করে এবং প্যাটার্নফাইন্ডারের কাছে হেরে)।

from collections import defaultdict
import random
class Number6:
    class Choices:
        def __init__(self, C = 0, N = 0, D = 0):
            self.C = C
            self.N = N
            self.D = D

    def __init__(self, strategy = "maxExpected", markov_order = 3):
        self.MARKOV_ORDER = markov_order;
        self.my_choices = "" 
        self.opponent = defaultdict(lambda: self.Choices())
        self.choice = None # previous choice
        self.payoff = {
            "C": { "C": 3-3, "N": 4-1, "D": 0-5 },
            "N": { "C": 1-4, "N": 2-2, "D": 3-2 },
            "D": { "C": 5-0, "N": 2-3, "D": 1-1 },
        }
        self.total_payoff = 0

        # if random, will choose in proportion to payoff.
        # otherwise, will always choose argmax
        self.strategy = strategy
        # maxExpected: maximize expected relative payoff
        # random: like maxExpected, but it chooses in proportion to E[payoff]
        # argmax: always choose the option that is optimal for expected opponent choice

    def update_opponent_model(self, last):
        for i in range(0, self.MARKOV_ORDER):
            hist = self.my_choices[i:]
            self.opponent[hist].C += ("C" == last)
            self.opponent[hist].N += ("N" == last)
            self.opponent[hist].D += ("D" == last)

    def normalize(self, counts):
        sum = float(counts.C + counts.N + counts.D)
        if 0 == sum:
            return self.Choices(1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0)
        return self.Choices(
            counts.C / sum, counts.N / sum, counts.D / sum)

    def get_distribution(self):
        for i in range(0, self.MARKOV_ORDER):
            hist = self.my_choices[i:]
            #print "check hist = " + hist
            if hist in self.opponent:
                return self.normalize(self.opponent[hist])

        return self.Choices(1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0)

    def choose(self, dist):
        payoff = self.Choices()
        # We're interested in *beating the opponent*, not
        # maximizing our score, so we optimize the difference
        payoff.C = (3-3) * dist.C + (4-1) * dist.N + (0-5) * dist.D
        payoff.N = (1-4) * dist.C + (2-2) * dist.N + (3-2) * dist.D
        payoff.D = (5-0) * dist.C + (2-3) * dist.N + (1-1) * dist.D

        # D has slightly better payoff on uniform opponent,
        # so we select it on ties
        if self.strategy == "maxExpected":
            if payoff.C > payoff.N:
                return "C" if payoff.C > payoff.D else "D"
            return "N" if payoff.N > payoff.D else "D"
        elif self.strategy == "randomize":
            payoff = self.normalize(payoff)
            r = random.uniform(0.0, 1.0)
            if (r < payoff.C): return "C"
            return "N" if (r < payoff.N) else "D"
        elif self.strategy == "argMax":
            if dist.C > dist.N:
                return "D" if dist.C > dist.D else "N"
            return "C" if dist.N > dist.D else "N"

        assert(0) #, "I am not a number! I am a free man!")

    def update_history(self):
        self.my_choices += self.choice
        if len(self.my_choices) > self.MARKOV_ORDER:
            assert(len(self.my_choices) == self.MARKOV_ORDER + 1)
            self.my_choices = self.my_choices[1:]

    def round(self, last):
        if last: self.update_opponent_model(last)

        dist = self.get_distribution()
        self.choice = self.choose(dist)
        self.update_history()
        return self.choice

class Ensemble:
    def __init__(self):
        self.models = []
        self.votes = []
        self.prev_choice = []
        for order in range(0, 6):
            self.models.append(Number6("maxExpected", order))
            self.models.append(Number6("randomize", order))
            #self.models.append(Number6("argMax", order))
        for i in range(0, len(self.models)):
            self.votes.append(0)
            self.prev_choice.append("D")

        self.payoff = {
            "C": { "C": 3-3, "N": 4-1, "D": 0-5 },
            "N": { "C": 1-4, "N": 2-2, "D": 3-2 },
            "D": { "C": 5-0, "N": 2-3, "D": 1-1 },
        }

    def round(self, last):
        if last:
            for i in range(0, len(self.models)):
                self.votes[i] += self.payoff[self.prev_choice[i]][last]

        # vote. Sufficiently terrible models get negative votes
        C = 0
        N = 0
        D = 0
        for i in range(0, len(self.models)):
            choice = self.models[i].round(last)
            if "C" == choice: C += self.votes[i]
            if "N" == choice: N += self.votes[i]
            if "D" == choice: D += self.votes[i]
            self.prev_choice[i] = choice

        if C > D and C > N: return "C"
        elif N > D: return "N"
        else: return "D"

টেস্ট ফ্রেমওয়ার্ক

অন্য কারও পক্ষে এটি দরকারী মনে হলে স্বতন্ত্র ম্যাচআপগুলি দেখার জন্য এখানে একটি পরীক্ষার কাঠামো রয়েছে। Python2। আপনার পছন্দসই প্রতিপক্ষগুলিকে কেবল প্রতিপক্ষ.পিতে আগ্রহী করুন এবং এনসেম্বেলে রেফারেন্সগুলি আপনার নিজের মধ্যে পরিবর্তন করুন।

import sys, inspect
import opponents
from ensemble import Ensemble

def count_payoff(label, them):
    if None == them: return
    me = choices[label]
    payoff = {
        "C": { "C": 3-3, "N": 4-1, "D": 0-5 },
        "N": { "C": 1-4, "N": 2-2, "D": 3-2 },
        "D": { "C": 5-0, "N": 2-3, "D": 1-1 },
    }
    if label not in total_payoff: total_payoff[label] = 0
    total_payoff[label] += payoff[me][them]

def update_hist(label, choice):
    choices[label] = choice

opponents = [ x[1] for x 
    in inspect.getmembers(sys.modules['opponents'], inspect.isclass)]

for k in opponents:
    total_payoff = {}

    for j in range(0, 100):
        A = Ensemble()
        B = k()
        choices = {}

        aChoice = None
        bChoice = None
        for i in range(0, 100):
            count_payoff(A.__class__.__name__, bChoice)
            a = A.round(bChoice)
            update_hist(A.__class__.__name__, a)

            count_payoff(B.__class__.__name__, aChoice)
            b = B.round(aChoice)
            update_hist(B.__class__.__name__, b)

            aChoice = a
            bChoice = b
    print total_payoff

— রশ্মি
সূত্র

কন্ট্রোলার প্রস্তুত, আপনাকে সমস্ত কিছুই করতে হবে না ...

— সাইনস্ট্যাকএফএল্ট

1

@ ব্ল্যাকসিলভার আমি বুঝতে পেরেছিলাম যে ঠিক আমি জমা দেওয়ার সময়ই । তবে এটি একটি 3.6 এর আগে সংস্করণগুলিতে কাজ করে এবং স্বতন্ত্র ম্যাচআপগুলি সম্পর্কে তথ্য দেয় যা দুর্বল দাগগুলি সনাক্ত করতে সহায়তা করতে পারে, তাই এটি সময় নষ্ট করার মতো ছিল না।

— রায়

যথেষ্ট ফর্সা; এখন চলছে আমি সম্ভবত আমার কন্ট্রোলারে অনুরূপ জিনিসগুলি করতে বিকল্পগুলি যুক্ত করব।

— সিগস্ট্যাকফোল্ট

"এটি এনসেম্বল এবং প্যাটার্নফাইন্ডার ব্যতীত পোস্ট করা সমস্ত কিছুকে পরাজিত করে" আমি সম্মানিত :)

— স্পার

@ স্পার উফস এভালুয়েটারবট এবং প্যাটার্নফাইন্ডার বলার কথা ছিল। পুরো ক্ষেত্রের সাথে মোট স্কোরের তুলনা করার সময়। প্যাটার্নফাইন্ডার একমাত্র রয়ে গেছে যে এটি সরাসরি ম্যাচ আপ করে।

— রায়

4

OldTitForTat

পুরাতন স্কুল প্লেয়ার নতুন নিয়মের জন্য আপডেট করতে খুব অলস।

class OldTitForTat:
    def round(self, last):
        if(last == None)
            return "C"
        if(last == "C"):
            return "C"
        return "D"

— জশুয়া
সূত্র

3

NeverCOOP

class NeverCOOP:
    def round(self, last):
        try:
            if last in "ND":
                return "D"
            else:
                return "N"
        except:
            return "N"

যদি বিরোধী বট ত্রুটিযুক্ত বা নিরপেক্ষ হয় তবে ত্রুটিটি চয়ন করুন। অন্যথায় যদি এটি প্রথম পালা হয় বা বিরোধী বট সহযোগিতা করে তবে নিরপেক্ষ নির্বাচন করুন। আমি নিশ্চিত না যে এটি কতটা ভাল কাজ করবে ...

— glietz
সূত্র

চেষ্টা / বাদে কি?

— সিগস্ট্যাকফোল্ট

1

@ ব্ল্যাকসিলভার আমি ধরে নেব যে এটি if(last):আপনার গ্রুডারের বট হিসাবে একই উদ্দেশ্যটি কাজ করে, এটি আবিষ্কার করে যে এর আগে কোনও গোল হয়েছিল whether

— ইটিএইচ প্রোডাকশনস

ওহহ আচ্ছা. None in "ND"ত্রুটি।

— সিগস্ট্যাকফোল্ট

কারণ if last and last in "ND":খুব জটিল ছিল?

— ব্যবহারকারী 253751

3

LastOptimalBot

class LastOptimalBot:
    def round(self, last):
        return "N" if last == "D" else ("D" if last == "C" else "C")

ধরে নেওয়া যায় যে বিরোধী বট সর্বদা আবার একই পদক্ষেপটি খেলবে এবং এর বিরুদ্ধে সবচেয়ে ভাল পরিশোধের জন্য একটি বেছে নেয়।

গড়:

Me   Opp
2.6  2    vs TitForTat
5    0    vs AllC
4    1    vs AllN
3    2    vs AllD
3.5  3.5  vs Random
3    2    vs Grudger
2    2    vs LastOptimalBot
1    3.5  vs TatForTit
4    1    vs NeverCOOP
1    4    vs EvaluaterBot
2.28 2.24 vs NashEquilibrium

2.91 average overall

— Spitemaster
সূত্র

নগদ টাকা। হয়তো টি 4 টি আরও ভাল করবে return last।

— সিগস্ট্যাকফুল্ট

আমি এটা চাই! যদি টাইটফোর্ডটি থাকত return last, এলওবি বর্তমানে এটি পাচ্ছে 13-10 ওভারের চেয়ে 6 রাউন্ডের চেয়ে 18-9 হয়ে। আমি মনে করি এটি ঠিক আছে - উদাহরণ বটগুলি অপ্টিমাইজ করার বিষয়ে চিন্তা করবেন না।

— স্পাইটমাস্টার

return lastএই চ্যালেঞ্জের জন্য আরও ভাল টি 4 টি হবে, আমি মনে করি

— স্পার

শুধু চেষ্টা করা হয়েছে - if(last): return last; else: return "C"আরও খারাপ।

— সিগস্ট্যাকফোল্ট

ঠিক আছে, তবে @ স্পার যেমনটি বলছিলেন, এটি আরও উপযুক্ত হতে পারে। আমি আপনাকে মনে করি।

— স্পাইটমাস্টার

3

copycat

class CopyCat:
    def round(self, last):
        if last:
            return last
        return "C"

প্রতিপক্ষের শেষ পদক্ষেপটি অনুলিপি করে।
আমি এটি ভাল করার আশা করি না, তবে এখনও কেউ এই ক্লাসিকটি কার্যকর করেনি।

— MannerPots
সূত্র

2

উন্নত ডিরিচলেট ডাইস

import random

class DirichletDice2:
    def __init__(self):

        self.alpha = dict(
                C = {'C' : 1, 'N' : 1, 'D' : 1},
                N = {'C' : 1, 'N' : 1, 'D' : 1},
                D = {'C' : 1, 'N' : 1, 'D' : 1}
        )
        self.myLast = [None, None]
        self.payoff = dict(
                C = { "C": 0, "N": 3, "D": -5 },
                N = { "C": -3, "N": 0, "D": 1 },
                D = { "C": 5, "N": -1, "D": 0 }
        )

    def DirichletDraw(self, key):
        alpha = self.alpha[key].values()
        mu = [random.gammavariate(a,1) for a in alpha]
        mu = [m / sum(mu) for m in mu]
        return mu

    def ExpectedPayoff(self, probs):
        expectedPayoff = {}
        for val in ['C','N','D']:
            payoff = sum([p * v for p,v in zip(probs, self.payoff[val].values())])
            expectedPayoff[val] = payoff
        return expectedPayoff

    def round(self, last):
        if last is None:
            self.myLast[0] = 'D'
            return 'D'

        #update dice corresponding to opponent's last response to my
        #outcome two turns ago
        if self.myLast[1] is not None:
            self.alpha[self.myLast[1]][last] += 1

        #draw probs for my opponent's roll from Dirichlet distribution and then return the optimal response
        mu = self.DirichletDraw(self.myLast[0])
        expectedPayoff = self.ExpectedPayoff(mu)
        res = max(expectedPayoff, key=expectedPayoff.get)

        #update myLast
        self.myLast[1] = self.myLast[0]
        self.myLast[0] = res

        return res

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

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

আসল জমা:

ডিরিচলেট ডাইস

import random

class DirichletDice:
    def __init__(self):

        self.alpha = dict(
                C = {'C' : 2, 'N' : 3, 'D' : 1},
                N = {'C' : 1, 'N' : 2, 'D' : 3},
                D = {'C' : 3, 'N' : 1, 'D' : 2}
        )

        self.Response = {'C' : 'D', 'N' : 'C', 'D' : 'N'}
        self.myLast = [None, None]

    #expected value of the dirichlet distribution given by Alpha
    def MultinomialDraw(self, key):
        alpha = list(self.alpha[key].values())
        probs = [x / sum(alpha) for x in alpha]
        outcome = random.choices(['C','N','D'], weights=probs)[0]
        return outcome

    def round(self, last):
        if last is None:
            self.myLast[0] = 'D'
            return 'D'

        #update dice corresponding to opponent's last response to my
        #outcome two turns ago
        if self.myLast[1] is not None:
            self.alpha[self.myLast[1]][last] += 1

        #predict opponent's move based on my last move
        predict = self.MultinomialDraw(self.myLast[0])
        res = self.Response[predict]

        #update myLast
        self.myLast[1] = self.myLast[0]
        self.myLast[0] = res

        return res

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

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

আমি কেবল পাশা ঘূর্ণায়মান এবং ফলাফলের প্রতিক্রিয়া না জানিয়ে একবার পাশা তৈরির সর্বোত্তম "প্রত্যাশিত" ফলাফলের সাথে সাড়া জাগাতে পারি। যাইহোক, আমি এলোমেলোতাটি রাখতে চাইছিলাম, যাতে আমার বটটি কোনও নিদর্শন পূর্বাভাস দেওয়ার চেষ্টা করে এমন লোকদের কাছে কম ঝুঁকিপূর্ণ হয়।

— Bridgeburners
সূত্র

2

কেভিন

class Kevin:
    def round(self, last):      
        return {"C":"N","N":"D","D":"C",None:"N"} [last]

সবচেয়ে খারাপ পছন্দ বাছাই করে। সবচেয়ে খারাপ বট তৈরি।

বেহুদা

import random

class Useless:
    def __init__(self):
        self.lastLast = None

    def round(self, last):
        tempLastLast = self.lastLast
        self.lastLast = last

        if(last == "D" and tempLastLast == "N"):
            return "C"
        if(last == "D" and tempLastLast == "C"):
            return "N"

        if(last == "N" and tempLastLast == "D"):
            return "C"
        if(last == "N" and tempLastLast == "C"):
            return "D"

        if(last == "C" and tempLastLast == "D"):
            return "N"
        if(last == "C" and tempLastLast == "N"):
            return "D"

        return random.choice("CND")

এটি প্রতিপক্ষের দ্বারা শেষ দুটি চালগুলি দেখায় এবং সর্বাধিক কাজটি না করে অন্যথায় এলোমেলোভাবে কিছু বাছাই করে। এটি করার আরও ভাল উপায় সম্ভবত আছে।

— Link1J
সূত্র

2

.তিহাসিক গড়

class HistoricAverage:
    PAYOFFS = {
        "C":{"C":3,"N":1,"D":5},
        "N":{"C":4,"N":2,"D":2},
        "D":{"C":0,"N":3,"D":1}}
    def __init__(self):
        self.payoffsum = {"C":0, "N":0, "D":0}
    def round(this, last):
        if(last != None):
            for x in this.payoffsum:
               this.payoffsum[x] += HistoricAverage.PAYOFFS[last][x]
        return max(this.payoffsum, key=this.payoffsum.get)

ইতিহাস দেখে এবং সেই ক্রিয়াটি আবিষ্কার করে যা গড়ে সেরা ছিল। সমবায় শুরু হয়।

— MegaTom
সূত্র

এটি যদি প্রতি রাউন্ডে গড় পুনরায় গণনা না করে তবে এটি দ্রুত চলতে পারে।

— স্পার

@ স্পার সত্য। আমি এটি সম্পাদনা করেছি তাই এটি এখন।

— মেগাটাইম

1

ওজন গড়

class WeightedAverageBot:
  def __init__(self):
    self.C_bias = 1/4
    self.N = self.C_bias
    self.D = self.C_bias
    self.prev_weight = 1/2
  def round(self, last):
    if last:
      if last == "C" or last == "N":
        self.D *= self.prev_weight
      if last == "C" or last == "D":
        self.N *= self.prev_weight
      if last == "N":
        self.N = 1 - ((1 - self.N) * self.prev_weight)
      if last == "D":
        self.D = 1 - ((1 - self.D) * self.prev_weight)
    if self.N <= self.C_bias and self.D <= self.C_bias:
      return "D"
    if self.N > self.D:
      return "C"
    return "N"

প্রতিপক্ষের আচরণ সিএনডির জন্য যথাক্রমে 0,0 0,1 1,0 এ কোণার সহ একটি সঠিক ত্রিভুজ হিসাবে মডেল করা হয়। প্রতিটি প্রতিপক্ষের পদক্ষেপটি সেই কোণার দিকে সেই ত্রিভুজের মধ্যে বিন্দুটি স্থানান্তরিত করে, এবং আমরা বিন্দু দ্বারা নির্দেশিত পদক্ষেপটি পরাজিত করতে খেলি (সি দিয়ে ত্রিভুজটির সামঞ্জস্যভাবে ছোট ছোট টুকরো দেওয়া হচ্ছে)। তত্ত্বের মধ্যে আমি এটি চেয়েছিলাম যে পূর্বের চালগুলির সাথে আরও ওজনযুক্ত একটি দীর্ঘ স্মৃতি থাকুক, তবে অনুশীলনে বর্তমান মেটা দ্রুত বদলে যাওয়া বটের পক্ষে, তাই এটি বেশিরভাগ শত্রুর বিরুদ্ধে লাস্টঅপটিমলবোটের সান্নিধ্যে রূপান্তরিত হয়। উত্তরোত্তর জন্য পোস্টিং; হয়তো কেউ অনুপ্রাণিত হবে।

— Sparr
সূত্র

1

Tetragram

import itertools

class Tetragram:
    def __init__(self):
        self.history = {x: ['C'] for x in itertools.product('CND', repeat=4)}
        self.theirs = []
        self.previous = None

    def round(self, last):
        if self.previous is not None and len(self.previous) == 4:
            self.history[self.previous].append(last)
        if last is not None:
            self.theirs = (self.theirs + [last])[-3:]

        if self.previous is not None and len(self.previous) == 4:
            expected = random.choice(self.history[self.previous])
            if expected == 'C':
                choice = 'C'
            elif expected == 'N':
                choice = 'C'
            else:
                choice = 'N'
        else:
            choice = 'C'

        self.previous = tuple(self.theirs + [choice])
        return choice

প্রতিপক্ষের চালগুলিতে একটি নমুনা সন্ধান করার চেষ্টা করুন, ধরে নিবেন তারা আমাদের শেষ পদক্ষেপটিও দেখছেন।

1

হ্যান্ডশেক

class HandshakeBot:
  def __init__(self):
    self.handshake_length = 4
    self.handshake = ["N","N","C","D"]
    while len(self.handshake) < self.handshake_length:
      self.handshake *= 2
    self.handshake = self.handshake[:self.handshake_length]
    self.opp_hand = []
    self.friendly = None
  def round(self, last):
    if last:
      if self.friendly == None:
        # still trying to handshake
        self.opp_hand.append(last)
        if self.opp_hand[-1] != self.handshake[len(self.opp_hand)-1]:
          self.friendly = False
          return "D"
        if len(self.opp_hand) == len(self.handshake):
          self.friendly = True
          return "C"
        return self.handshake[len(self.opp_hand)]
      elif self.friendly == True:
        # successful handshake and continued cooperation
        if last == "C":
          return "C"
        self.friendly = False
        return "D"
      else:
        # failed handshake or abandoned cooperation
        return "N" if last == "D" else ("D" if last == "C" else "C")
    return self.handshake[0]

এটি নিজের বিরুদ্ধে খেললে স্বীকৃতি দেয়, তারপরে সহযোগিতা করে। অন্যথায় লাস্টঅપ્টিমালবোটকে নকল করে যা সেরা এক-লাইনের কৌশল বলে মনে হয়। রাউন্ডের সংখ্যার বিপরীতে আনুপাতিক পরিমাণে, লাস্টওপটিমলবটের চেয়ে খারাপ কাজ করে। অবশ্যই যদি ক্ষেত্রের * কাশি ** উইঙ্ক * এর আরও অনুলিপি থাকে তবে আরও ভাল করতে পারে।

— Sparr
সূত্র

কেবলমাত্র কয়েকটি ক্লোন জমা দিন যার মধ্যে নন-হ্যান্ডশেকের আচরণ রয়েছে।

— সিগস্ট্যাকফোল্ট

এটি শোষণ-y বলে মনে হচ্ছে। আমি এখানে প্রতিনিধিত্ব করা প্রতিটি সাধারণ আচরণের জন্য এই জাতীয় একটি ক্লোন জমা দিতে পারতাম।

— স্পার

আমি একটি অতিরিক্ত ধারা যুক্ত করে জানিয়েছি যে আপনি কেবল সর্বোচ্চ পাঁচটি বট জমা দিতে পারবেন।

— সিগস্ট্যাকফোল্ট

1

ShiftingOptimalBot

class ShiftingOptimalBot:
    def __init__(self):
        # wins, draws, losses
        self.history = [0,0,0]
        self.lastMove = None
        self.state = 0
    def round(self, last):
        if last == None:
            self.lastMove = "C"
            return self.lastMove
        if last == self.lastMove:
            self.history[1] += 1
        elif (last == "C" and self.lastMove == "D") or (last == "D" and self.lastMove == "N") or (last == "N" and self.lastMove == "C"):
            self.history[0] += 1
        else:
            self.history[2] += 1

        if self.history[0] + 1 < self.history[2] or self.history[2] > 5:
            self.state = (self.state + 1) % 3
            self.history = [0,0,0]
        if self.history[1] > self.history[0] + self.history[2] + 2:
            self.state = (self.state + 2) % 3
            self.history = [0,0,0]

        if self.state == 0:
            self.lastMove = "N" if last == "D" else ("D" if last == "C" else "C")
        elif self.state == 1:
            self.lastMove = last
        else:
            self.lastMove = "C" if last == "D" else ("N" if last == "C" else "D")
        return self.lastMove

এই বটটি যতক্ষণ না এটি লস্টঅপটিমালবটের অ্যালগরিদম ব্যবহার করে। অন্য বট যদি এটি পূর্বাভাস দেওয়া শুরু করে, তবে, এটি তার প্রতিপক্ষের সর্বশেষে যে কোনও পদক্ষেপে খেলতে শুরু করবে (এটি এমন পদক্ষেপ যা লাস্টওপটিমলবোটকে পরাস্ত করবে move যতক্ষণ না এটি হারাতে থাকে ততক্ষণ এই অ্যালগোরিদমের সাধারণ ট্রান্সপোজিশনের মধ্য দিয়ে এটি চক্র হয় (বা যখন এটি অনেক বেশি আঁকিয়ে উদাস হয়ে যায়)।

সত্যি বলতে, আমি অবাক হয়েছি যে লস্টঅપ્টিমালবট এই পোস্ট করার সাথে সাথে 5 তম স্থানে বসে আছেন। আমি মোটামুটি নিশ্চিত যে এটি আরও ভাল করবে, ধরে নিই যে আমি এই অজগরটি সঠিকভাবে লিখেছি।

— Spitemaster
সূত্র

0

HandshakePatternMatch

from .patternfinder import PatternFinder
import collections

class HandshakePatternMatch:
    def __init__(self):
        self.moves = [None]
        self.other = []
        self.handshake = [None,"N","C","C","D","N"]
        self.friendly = None
        self.pattern = PatternFinder()
    def round(self, last):
        self.other.append(last)
        if last:
            if len(self.other) < len(self.handshake):
                # still trying to handshake
                if self.friendly == False or self.other[-1] != self.handshake[-1]:
                    self.friendly = False
                else:
                    self.friendly = True
                move = self.handshake[len(self.other)]
                self.pattern.round(last)
            elif self.friendly == True:
                # successful handshake and continued cooperation
                move = self.pattern.round(last)
                if last == "C":
                    move = "C"
                elif last == self.handshake[-1] and self.moves[-1] == self.handshake[-1]:
                    move = "C"
                else:
                    self.friendly = False
            else:
                # failed handshake or abandoned cooperation
                move = self.pattern.round(last)
        else:
            move = self.handshake[1]
            self.pattern.round(last)
        self.moves.append(move)
        return move

প্যাটার্ন কেন নিজেকে মেলে? হ্যান্ডশেক এবং সহযোগিতা দূরে।

— Draco18s
সূত্র

import PatternFinderআমার বইতে প্রতারণা করছে।

— সাইনস্ট্যাকএফএল্ট

@ ব্ল্যাকসিলভার এটি সবসময়ই কোঠায় সম্পন্ন হয়। এটি বিদ্যমান উত্তরে কোডটি অনুলিপি করা এবং এটি ব্যবহার করার চেয়ে আলাদা নয়।রোবট রুলেট: উচ্চতর অংশীদার রোবট জুয়া খেলার জায়গা জুড়ে এমনটি ঘটেছিল যে বটগুলি সনাক্ত করবে যদি তাদের কোড কোনও প্রতিপক্ষের দ্বারা ডেকেছিল এবং প্রত্যাবর্তনকে নাশকতা করে।

— ড্রাকো

তাহলে ঠিকআছে. তিল।

— সাইনস্ট্যাকএফএলএফ

আমি আগামীকাল ক্রাঞ্চিং করব।

— সাইনস্ট্যাকএফএল্ট

অন্যান্য বট কোড ব্যবহারের নিখুঁত উদাহরণ এখানে । সাধারণত এটি নেমে আসে "এই লোকটি কিছু জটিল গণিত তৈরি করেছিল, আমি এই পরিস্থিতিতে তার ফলাফল চাই" " (আমার নিজের প্রবেশে এটি বেশ ভাল প্রভাব ফেলেছিল; আপ আপনার সময়গুলি আরও বেশি ছড়িয়ে পড়েছিল)।

— ড্রাকো

0

হার্ডকোডেড

class Hardcoded:
    sequence = "DNCNNDDCNDDDCCDNNNNDDCNNDDCDCNNNDNDDCNNDDNDDCDNCCNNDNNDDCNNDDCDCNNNDNCDNDNDDNCNDDCDNNDCNNDDCDCNNDNNDDCDNDDCCNNNDNNDDCNNDDNDCDNCNDDCDNNDDCCNDNNDDCNNNDCDNDDCNNNNDNDDCDNCDCNNDNNDDCDNDDCCNNNDNDDCNNNDNDCDCDNNDCNNDNDDCDNCNNDDCNDNNDDCDNNDCDNDNCDDCNNNDNDNCNDDCDNDDCCNNNNDNDDCNNDDCNNDDCDCNNDNNDDCDNDDCCNDNNDDCNNNDCDNNDNDDCCNNNDNDDNCDCDNNDCNNDNDDCNNDDCDNCNNDDCDNNDCDNDNCDDCNDNNDDCNNNDDCDNCNNDNNDDCNNDDNNDCDNCNDDCNNDCDNNDDCNNDDNCDCNNDNDNDDCDNCDCNNNDNDDCDCNNDNNDDCDNDDCCNNNDNNDDCNDNDNCDDCDCNNNNDNDDCDNCNDDCDNNDDCNNNDNDDCDNCNNDCNNDNDDNCDCDNNNDDCNNDDCNNDDNNDCDNCNDDCNNDDNDCDNNDNDDCCNCDNNDCNNDDNDDCNCDNNDCDNNNDDCNNDDCDCDNNDDCNDNCNNDNNDNDNDDCDNCDCNNNDNDDCDNCNNDDCDNNDCNNDDCNNDDCDCDNNDDCNDNCNNNDDCDNNDCDNDNCNNDNDDNNDNDCDDCCNNNDDCNDNDNCDDCDCNNNDNNDDCNDCDNDDCNNNNDNDDCCNDNNDDCDCNNNDNDDNDDCDNCCNNDNNDDCNNDDCDCNNDNNDDCNNDDNCNDDNNDCDNCNDDCNNDDNDCDNNDNDDCCNCDNNDCNNDNDDCNNDDNCDCDNNDCNNDNDDCDCDNNNNDDCNNDDNDCCNNDDNDDCNCDNNDCNNDDNDDCDNCNDDCNNNNDCDNNDDCNDNDDCDNCNNDCDNNDCNNDNDDNCDCNNDNDDCDNDDCCNNNNDNDDCNNDDCDCNNDNNDDCDCDNNDDC"
    def __init__(self):
        self.round_num = -1
    def round(self,_):
        self.round_num += 1
        return Hardcoded.sequence[self.round_num % 1000]

শীর্ষস্থানীয় কয়েকটি ডিটারমিনিটিক বটকে পরাজিত করতে অনুকূলিত পদক্ষেপগুলির একটি হার্ডকোডযুক্ত ক্রম খেলে।

— MegaTom
সূত্র

কারাগারের ট্রাইলেমা te

সুনির্দিষ্ট

নিয়ামক

অন্যান্য ভাষাসমূহ

স্কোর: 2018-11-27

EvaluaterBot

NashEquilibrium

TatForTit

PatternFinder

জেড

আঁসাঁব্ল

টেস্ট ফ্রেমওয়ার্ক

OldTitForTat

NeverCOOP

LastOptimalBot

copycat

উন্নত ডিরিচলেট ডাইস

ডিরিচলেট ডাইস

কেভিন

বেহুদা

.তিহাসিক গড়

ওজন গড়

Tetragram

হ্যান্ডশেক

ShiftingOptimalBot

HandshakePatternMatch

হার্ডকোডেড