ক্ষুদ্রতম অনন্য নম্বর কোএইচটি

Question

ক্ষুদ্রতম অনন্য সংখ্যা চয়ন করতে একটি বট তৈরি করুন।

(মনোবিজ্ঞানের পরীক্ষার ভিত্তিতে আমি প্রায় বহু বছর আগে শুনেছি কিন্তু আবার সন্ধান করতে সক্ষম হইনি))

বিধি

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

বিশেষ উল্লেখ

বটগুলি অবশ্যই পাইথন 3 শ্রেণি হতে হবে এবং অবশ্যই দুটি পদ্ধতি প্রয়োগ করতে হবে: selectএবং update।
বটগুলি একটি সূচক দিয়ে তৈরি করা হবে।
selectকোনও আর্গুমেন্ট পাস করা হয় এবং বর্তমান রাউন্ডের জন্য বটের পছন্দটি ফেরত দেয়।
updateপূর্ববর্তী রাউন্ডে প্রতিটি বট দ্বারা করা পছন্দগুলির একটি তালিকা পাস করা হয়।

উদাহরণ

class Lowball(object):
    def __init__(self, index):
        # Initial setup happens here.
        self.index = index
    def select(self):
        # Decision-making happens here.
        return 1
    def update(self, choices):
        # Learning about opponents happens here.
        # Note that choices[self.index] will be this bot's choice.
        pass

নিয়ামক

import numpy as np

from bots import allBotConstructors
allIndices = range(len(allBotConstructors))
games = {i: 0 for i in allIndices}
wins = {i: 0 for i in allIndices}

for _ in range(200 * len(allBotConstructors)):
    # Choose players.
    playerIndices = np.random.choice(allIndices, 10, replace=False)
    players = [allBotConstructors[j](i) for i, j in enumerate(playerIndices)]

    scores = [0] * 10
    for _ in range(1000):
        # Let everyone choose a value.
        choices = [bot.select() for bot in players]
        for bot in players:
            bot.update(choices[:])

        # Find who picked the best.
        unique = [x for x in choices if choices.count(x) == 1]
        if unique:
            scores[choices.index(min(unique))] += 1

    # Update stats.
    for i in playerIndices:
        games[i] += 1
    bestScore = max(scores)
    for i, s in enumerate(scores):
        if s == bestScore:
            wins[playerIndices[i]] += 1

winRates = {i: wins[i] / games[i] for i in allIndices}
for i in sorted(winRates, key=lambda i: winRates[i], reverse=True):
    print('{:>40}: {:.4f} ({}/{})'.format(allBotConstructors[i], winRates[i], wins[i], games[i]))

অতিরিক্ত তথ্য

• কোনও বট নিজের বিরুদ্ধে খেলায় খেলবে না।
• একটি বট 100 টিরও কম গেমের অন্তর্ভুক্ত হওয়ার সম্ভাব্য ইভেন্টে, টুর্নামেন্টটি আবার চালু হবে।
• বটগুলি রাউন্ডের মধ্যে রাষ্ট্র সঞ্চয় করতে পারে তবে গেমগুলির মধ্যে নয়।
• নিয়ামক বা অন্যান্য বট অ্যাক্সেস অনুমোদিত নয়।
• ফলাফলগুলি খুব পরিবর্তনশীল হলে গেমের প্রতি গেমের সংখ্যা এবং রাউন্ডের সংখ্যা বাড়তে পারে to
• ত্রুটি বাড়াতে বা অবৈধ প্রতিক্রিয়া জানানো (নন-ইনটস, [1, 10] এর বাইরে মান ইত্যাদি) যে কোনও বট অযোগ্য ঘোষণা করা হবে এবং সেগুলি ছাড়াই টুর্নামেন্ট পুনরায় চালু করা হবে।
• রাউন্ডগুলির জন্য কোনও সময়সীমা নেই, তবে বটগুলি চিন্তা করতে খুব বেশি সময় নিলে আমি এটি প্রয়োগ করতে পারি।
• ব্যবহারকারী হিসাবে জমা দেওয়ার সংখ্যার কোনও সীমা নেই।
• জমা দেওয়ার শেষ সময়সীমা ২৩:৫৯:59 ইউটিসি শুক্রবার, ২৮ সেপ্টেম্বর। টুর্নামেন্টটি এখন জমা দেওয়ার জন্য বন্ধ রয়েছে।

ফলাফল

                BayesBot: 0.3998 (796/1991)
      WhoopDiScoopDiPoop: 0.3913 (752/1922)
           PoopDiScoopty: 0.3216 (649/2018)
                   Water: 0.3213 (660/2054)
                 Lowball: 0.2743 (564/2056)
                Saboteur: 0.2730 (553/2026)
                OneUpper: 0.2640 (532/2015)
         StupidGreedyOne: 0.2610 (516/1977)
          SecondSaboteur: 0.2492 (492/1974)
                    T42T: 0.2407 (488/2027)
                     T4T: 0.2368 (476/2010)
          OpportunityBot: 0.2322 (454/1955)
              TheGeneral: 0.1932 (374/1936)
             FindRepeats: 0.1433 (280/1954)
                  MinWin: 0.1398 (283/2025)
             LazyStalker: 0.1130 (226/2000)
               FollowBot: 0.1112 (229/2060)
                Assassin: 0.1096 (219/1999)
           MostlyAverage: 0.0958 (194/2024)
             UnchosenBot: 0.0890 (174/1955)
                 Raccoon: 0.0868 (175/2015)
               Equalizer: 0.0831 (166/1997)
       AvoidConstantBots: 0.0798 (158/1980)
WeightedPreviousUnchosen: 0.0599 (122/2038)
               BitterBot: 0.0581 (116/1996)
               Profiteur: 0.0564 (114/2023)
              HistoryBot: 0.0425 (84/1978)
            ThreeFourSix: 0.0328 (65/1984)
                 Stalker: 0.0306 (61/1994)
             Psychadelic: 0.0278 (54/1943)
              Unpopulist: 0.0186 (37/1994)
             PoissonsBot: 0.0177 (35/1978)
         RaccoonTriangle: 0.0168 (33/1964)
              LowHalfRNG: 0.0134 (27/2022)
              VictoryPM1: 0.0109 (22/2016)
            TimeWeighted: 0.0079 (16/2021)
             TotallyLost: 0.0077 (15/1945)
            OneTrackMind: 0.0065 (13/1985)
              LuckySeven: 0.0053 (11/2063)
          FinalCountdown: 0.0045 (9/2000)
                Triangle: 0.0039 (8/2052)
           LeastFrequent: 0.0019 (4/2067)
                Fountain: 0.0015 (3/1951)
             PlayerCycle: 0.0015 (3/1995)
                  Cycler: 0.0010 (2/1986)
               SecureRNG: 0.0010 (2/2032)
             SneakyNiner: 0.0005 (1/2030)
            I_Like_Nines: 0.0000 (0/1973)

Comments

@ স্মারক কোন খবর?

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

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

@ স্মারক এটি এখনও শেষ হয়েছে?

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

@ জাস্টিন এটি এখনই চলমান, এবং ক্রাশ হচ্ছে বলে মনে হচ্ছে না, তবে এই রানটি ব্যর্থ হলে অবশ্যই আমি সাহায্যের পক্ষে আপত্তি করব না।

@ মিহাইলমালোস্টানিডিস bots.pyএকই ডিরেক্টরিতে ডাকা একটি ফাইল তৈরি করুন যাতে সমস্ত বট থাকে। শেষে, নির্মাণকারীদের একটি তালিকা তৈরি করুন:allBotConstructors = [Lowball, BayesBot, ...]

Answer 1

BayesBot

একটি সাধারণ পরিসংখ্যান মডেল ব্যবহার করে অনুকূল পছন্দ করার চেষ্টা করে।

import random

def dirichlet(counts):
    counts = [random.gammavariate(n, 1) for n in counts]
    k = 1. / sum(counts)
    return [n * k for n in counts]

class BayesBot(object):
    def __init__(self, index):
        self.index = index
        self.counts = [[0.2 * (10 - i) for i in range(10)] for _ in range(10)]
    def select(self):
        player_distributions = []
        for i, counts in enumerate(self.counts):
            if i == self.index:
                continue
            player_distributions.append(dirichlet(counts))
        cumulative_unique = 0.
        scores = [0.] * 10
        for i in range(10):
            p_unpicked = 1.
            for d in player_distributions:
                p_unpicked *= (1. - d[i])
            p_unique = p_unpicked * sum(d[i] / (1. - d[i]) for d in player_distributions)
            scores[i] = p_unpicked * (1. - cumulative_unique)
            cumulative_unique += p_unique * (1. - cumulative_unique)
        return scores.index(max(scores)) + 1
    def update(self, choices):
        for i, n in enumerate(choices):
            self.counts[i][n - 1] += 1

Answer 2

কনস্ট্যান্ট বটগুলি এড়িয়ে চলুন

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

import numpy as np

class AvoidConstantBots(object):
    all_values = range(1, 11)
    def __init__(self, index):
        self.index = index
        self.constant_choices = None

    def select(self):
        available = set(self.all_values)
        if self.constant_choices is not None:
            available -= set(self.constant_choices)
        if len(available) == 0:
            available = set(self.all_values)
        values = np.array(sorted(available))
        weights = 1. / (np.arange(1, len(values) + 1)) ** 1.5
        weights /= sum(weights)
        return np.random.choice(sorted(available), p=weights)

    def update(self, choices):
        if self.constant_choices is None:
            self.constant_choices = choices[:]
            self.constant_choices[self.index] = None
        else:
            for i, choice in enumerate(choices):
                if self.constant_choices[i] != choice:
                    self.constant_choices[i] = None

Answer 3

WaitWhatBot

সর্বাধিক প্রতিযোগিতামূলক বট নয় এবং অবশ্যই জিটিও নয় , তবে একই খেলায় যে কোনও "সর্বদা 1" বা "প্রায় সর্বদা 1" প্রতিপক্ষের স্কোরকে প্রশ্রয় দেয় যেমন ওয়েটওয়্যাটবটও এমন বট হয়ে যায় such

উভয় সময়ে ওজনযুক্ত ওজনযুক্ত (সম্ভবত সাম্প্রতিক -> বৃহত্তর ওজন) এবং পছন্দ মান (নিম্ন পয়েন্ট -> বৃহত্তর ওজন) উভয় সহ বিবর্তিত সম্ভাবনার ব্যবহার করে।

কিছুটা জিগ্লির জন্য কিছুটা অবলম্বন কোড ব্যবহার করে।

from random import choices as weightWeight
class WaitWhatBot(object):
    def __init__(wait,what):
        weight,weightWhat=5,2
        wait.what,wait.weight=what,(weight**(weight/weight/weightWhat)+weightWhat/weightWhat)/weightWhat
        wait.whatWeight,wait.weightWeight=[wait.what==wait.weight]*int(wait.weight**weight),wait.weight
        wait.whatWhat=wait.whatWeight.pop()#wait, when we pop weight off whatWeight what weight will pop?
        wait.waitWait=tuple(zip(*enumerate(wait.whatWeight,wait.weightWeight!=wait.whatWeight)))[weightWeight==wait.weight]
    def select(what):return int(what.weight**what.whatWhat if all(not waitWait for waitWait in what.whatWeight)else weightWeight(what.waitWait,what.whatWeight)[what.weight==what.what])
    def update(waitWhat,whatWait):
        what,wait,weightWhat=set(wait for wait in whatWait[:waitWhat.what]+whatWait[waitWhat.what+1:]if wait in waitWhat.waitWait),-~waitWhat.whatWhat,waitWhat.weightWeight
        while wait not in what:
            waitWhat.whatWeight[wait+~waitWhat.whatWhat]+=weightWhat
            weightWhat/=waitWhat.weight
            wait-=~waitWhat.whatWhat
        if not wait!=(what!=weightWhat):waitWhat.whatWeight[waitWhat.whatWhat]+=weightWhat
        waitWhat.weightWeight*=waitWhat.weight

Comments

ওয়েটওয়্যাটবট কত ওজন কিনে ফেলত, যদি ওয়েটওয়্যাটবট ওজন কিনে তবে?

— রোমান ওডাইস্কি

সেট করুন ([… এর জন্য… ইন…]) ≡ {… এর জন্য… ইন…},

— যাইহোক

@ রোমানওডাইস্কি আমি আসলে অন্য কাউকে একটি গল্ফের জন্য পরামর্শ দিয়েছিলাম!

— জোনাথন অ্যালান

Answer 4

উত্ত্যক্তকারীর

গেমের শুরুতে, এই বটটি এলোমেলোভাবে একটি নির্দিষ্ট সূচককে তার লক্ষ্য হিসাবে বেছে নেয়। এরপরে এটি ডালপালা করে যা পুরো গেমকে লক্ষ্য করে, এটি আগের রাউন্ডে যে নম্বরটি পছন্দ করেছিল তা অনুলিপি করে।

import random

class Stalker(object):
  def __init__(self, index):
    # choose a random target to stalk that isn't ourself
    self.targetIndex = random.choice([x for x in range(10) if x != index])
    # get a random number to start with since we haven't seen our target's value yet
    self.targetValue = random.randint(1, 10)
  def select(self):
    return self.targetValue
  def update(self, choices):
    # look at what our target chose last time and do that
    self.targetValue = choices[self.targetIndex]

Answer 5

বোকা লোভী এক

class StupidGreedyOne(object):
    def __init__(self, index):
        pass
    def select(self):
        return 1
    def update(self, choices):
        pass

এই বটটি ধরে নিয়েছে যে অন্য বটগুলি টাই করতে চায় না।

_{আমি বুঝতে পারি এটি প্রদত্ত উদাহরণ হিসাবে একই তবে আমি এতদূর পড়ার আগে আমার চিন্তাভাবনা ছিল। এটি যদি কোএইচটি চ্যালেঞ্জগুলি কীভাবে চালিত হয় তা যদি অসম্পূর্ণ হয় তবে আমাকে জানান।}

Comments

সাধারণভাবে আমি সদৃশ বট না রাখাই পছন্দ করি তবে এটি ছেড়ে দিতে আমার আপত্তি নেই।

@ স্মারক প্রযুক্তিগতভাবে এটি কোনও ডুপ নয়, কারণ এটি আরম্ভ হয় না self.index।

— hidefromkgb

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

— ইঞ্জিনিয়ার টোস্ট

কোন চিন্তা করো না. কোথার অপূর্ব পৃথিবীতে আপনাকে স্বাগতম!

আপনি একটি "টেক্কা গ্রেনেড": puzzling.stackexchange.com/

— প্রশ্নগুলি

Answer 6

HistoryBot

import random

class HistoryBot(object):
    def __init__(self, index):
        self.pastWins = []
    def select(self):
        if not self.pastWins:
            return 1
        return random.choice(self.pastWins)
    def update(self, choices):
        unique = [x for x in choices if choices.count(x) == 1]
        if unique:
            self.pastWins.append(min(unique))

ব্যবহারকারী 2390246 এর মন্তব্য বাস্তবায়ন:

এই তাহলে কি? প্রথম দিয়ে শুরু করুন 1.. প্রথম রাউন্ডের পরে, বিজয়ী মানগুলি ট্র্যাক করুন এবং ঘটনার সংখ্যার সমান সম্ভাবনা সহ এগুলি থেকে এলোমেলোভাবে বেছে নিন। উদাহরণস্বরূপ যদি প্রথম তিন রাউন্ডের বিজয়ী মানগুলি [2, 3, 2] হয় তবে চতুর্থ রাউন্ডে, পি = 2/3 এবং [3] পি = 1/3 এর সাথে [2] বাছুন।

Answer 7

OneUpper

class OneUpper(object):
    def __init__(self, index):
        self.index = index
    def select(self):
        return 2
    def update(self, choices):
        pass

অন্য সকলের বট হয় হয় 1 বা এলোমেলো লক্ষ্য করে, তবে কেন কেবল 2 এর জন্য লক্ষ্য রাখছেন না?

Answer 8

জলের মতো প্রবাহিত

প্রতিটি সংখ্যাকে দ্বিগুণ করে মৌলিক ধ্রুবক বট সনাক্তকরণ অ্যালগরিদমগুলি এড়িয়ে চলেন, যদি অচল অবস্থায় থাকে তবে নিম্ন মানের দিকে ধীরে ধীরে অগ্রসর হন।

class Water(object):
    def __init__(self, index):
        self.index = index
        self.round = 0
        self.play = 4
        self.choices = [0]*10

    def select(self):
        if self.round > 0 and self.round%2 == 0:
            if not max([1, self.play - 1]) in self.choices:
                self.play -= 1
        return self.play

    def update(self, choices):
        self.round += 1
        self.choices = choices

Comments

আমি কৌতুহলী, আপনার বটটি কোনওভাবে আমার ঝর্ণার সাথে সম্পর্কিত ? দু'জনেই "জলমুখী", হাহা।

— রেডক্লুভার

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

— টিসিএফপি

সুতরাং আমি চালিত প্রতিটি পরীক্ষায় এটি তৃতীয় বা চতুর্থ (সাধারণত তৃতীয়) পাচ্ছে। এই জাতীয় কৌশলটির জন্য এটি বেশ আশ্চর্যজনক।

— রবার্ট ফ্রেজার 21

Answer 9

সম্পূর্ণ হারিয়েছেন

class TotallyLost(object):
    def __init__(self, index):
        self.index = index
        self.round = 0
        self.numbers = [4,8,1,5,1,6,2,3,4,2]
    def select(self):
        return self.numbers[self.round % len(self.numbers)]
    def update(self, choices):
        self.round = self.round + 1

Answer 10

ফাইনাল কাউন্টডাউন

class FinalCountdown(object):
    def __init__(self, index):
        self.round = -1
    def select(self):
        self.round += 1
        return (10 - self.round // 100)
    def update(self, choices):
        pass

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

প্রথম 100 টি রাউন্ডের জন্য 10, পরবর্তী 100 এর জন্য 9 এবং আরও অনেক কিছু আসে।

Answer 11

Opportunitybot

এই বটটি প্রতি রাউন্ডে (কোনও সর্বনিম্ন উপলব্ধ সংখ্যা, বা সুযোগ) অন্য কোনও বট দ্বারা নির্বাচিত না সর্বনিম্ন সংখ্যার উপর নজর রাখে এবং সেই সংখ্যাটি সবচেয়ে বেশি ঘন ঘন এটি চালিয়ে যায়।

class OpportunityBot(object):
    def __init__(self, index):
        self.index = index
        self.winOccasions = [0,0,0,0,0,0,0,0,0,0]

    def select(self):
        return self.winOccasions.index(max(self.winOccasions))+1

    def update(self, choices):
        choices.pop(self.index)
        succeeded = [choices.count(i)==0 for i in range(1,11)]
        self.winOccasions[succeeded.index(True)] += 1

Answer 12

PatterMatcher

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

class PatternMatcher(object):
    def __init__(self, index):
        self.bots=[[]]*9
        self.index=index
    def select(self):
        minVisible=3    #increase these if this bot is to slow
        minOccurences=2
        predictions=set()
        for bot in self.bots:     
            #match patters of the form A+(B+C)*minOccurences+B and use C[0] as a prediction      
            for lenB in range(minVisible,len(bot)//(minVisible+1)+1):
                subBot=bot[:-lenB]
                patterns=[] 
                for lenBC in range(lenB,len(subBot)//minOccurences+1):
                    BC=subBot[-lenBC:]
                    for i in range(1,minOccurences):
                        if BC!=subBot[-lenBC*i-lenBC:-lenBC*i]:
                            break
                    else:
                        patterns.append(BC)
                predictions|={pattern[lenB%len(pattern)] for pattern in patterns}
        other=set(range(1,11))-predictions
        if other: return min(other)
        else: return 1                

    def update(self, choices):
        j = 0
        for i,choice in enumerate(choices):
            if i == self.index:
                continue
            self.bots[j].append(choice)
            j += 1

ত্রিভুজ

এন বাছাইয়ের সুযোগটি (10-n)/45

import random
class Triangle(object):
    def __init__(self, index):pass
    def select(self):return random.choice([x for x in range(1, 11) for _ in range(10 - x)])
    def update(self, choices):pass

TimeWeighted

বট কোনও সংখ্যা চয়ন করার সম্ভাবনা সমানুপাতিক (10-n)*Δt। এটি প্রথম রাউন্ডটি ত্রিভুজটির অনুরূপ।

import random
class TimeWeighted(object):
    def __init__(self, index):
        self.last=[0]*10
        self.round=1 
    def select(self):
        weights=[(self.round-self.last[i])*(10-i) for i in range(10)]
        return 1+random.choice([x for x in range(10) for _ in range(weights[x])])

    def update(self, choices):
        for c in choices:
            self.last[c-1]=self.round
        self.round+=1

LeastFrequent

কমপক্ষে ঘন ঘন ঘটে যাওয়া সংখ্যা জমা দেয়, যদি তারা সমান হয় তবে সর্বনিম্ন একটিটি নিন।

class LeastFrequent(object):
    def __init__(self, index):self.frequenties=[0]*10
    def select(self):return 1+self.frequenties.index(min(self.frequenties))
    def update(self, choices):
        for c in choices:
            self.frequenties[c-1]+=1

দীর্ঘতম সময়

ফ্রিকোয়েন্সিগুলির সাথে একই তবে জমা দেওয়ার মধ্যে দীর্ঘতম সময়ের সাথেও।

class LongestTime(object):
    def __init__(self, index):
        self.frequencies=[0]*10
        self.round=1
    def select(self):return 1+self.frequencies.index(min(self.frequencies))
    def update(self, choices):
        for c in choices:
            self.frequencies[c-1]=self.round
        self.round+=1

অন্তর্ঘাতক

সর্বশেষতম জমা দেওয়া হয়েছে যা গতবার জমা হয়েছিল।

class Saboteur(object):
    def __init__(self, index):self.last=[1]
    def select(self):return min(self.last)
    def update(self, choices):self.last=choices

SecondSaboteur

দ্বিতীয় সর্বনিম্ন নম্বর জমা দেয় যা গতবার জমা দেওয়া হয়েছিল

class SecondSaboteur(object):
    def __init__(self, index):self.last=[1,2]
    def select(self):return min({i for i in self.last if i!=min(self.last)})
    def update(self, choices):self.last=choices

Profiteur

সর্বশেষতম জমা দেওয়া হয়নি গত বার

class Profiteur(object):
    def __init__(self, index):self.last=set()
    def select(self):return min(set(range(1, 11))-self.last, default=1)
    def update(self, choices):self.last=set(choices)

দুঃখিত আমি আগের বার একবার প্রয়োগ করার সময় নতুন বটগুলির জন্য ধারণা পেয়ে কিছুটা দূরে সরে এসেছি। আমি নিশ্চিত ছিলাম না কোনটি সেরা হবে এবং আমি তাদের প্রত্যেকের অভিনয় সম্পর্কে আগ্রহী। আপনি সেগুলি এখানে পেতে পারেন: https://repl.it/@Fejfo/Lowest-Unique-Number

Comments

খুশী হলাম। আপনি সাবোটিউরকে তার নিজের শেষ পছন্দটি উপেক্ষা করার জন্য সংশোধন করার বিষয়টি বিবেচনা করতে পারেন (যদি না তা উদ্দেশ্যমূলক হয়)। এছাড়াও, আমি মনে করি আপনার কয়েকটি বিশেষ কেসগুলি হ্যান্ডেল করার দরকার হতে পারে: সেকেন্ডস্যাবোটোরকে কি করা উচিত যদি প্রতিটি বট কিছু গোলের মধ্যে একই মান পছন্দ করে, এবং প্রতিটি বট যদি আলাদা মান পছন্দ করে তবে প্রফিটর কী করবেন? আপনার পরে প্রফিটরে একটি শেষ বন্ধনী প্রয়োজন হতে পারে set(range(10)।

— মনিকা পুনঃস্থাপন

প্যাটার্নম্যাচারের মনে হয় কিছু ধরণের অসীম লুপ বা জায়গা যেখানে এটি আটকে যায়।

— রবার্ট ফ্রেজার

Answer 13

শীর্ষ 50% আরএনজি বট

import random

class LowHalfRNG(object):
    def __init__(self, index):
        pass
    def select(self):
        return random.randint(1, 5)
    def update(self, choices):
        pass

আমি একটি এলোমেলো বট পোস্ট করতে যাচ্ছিলাম, তবে আমার আগে লুকিয়ে রাখা পোস্ট (পোস্ট করে তারা কেজিবির পক্ষে নিজেকে একটি সহজ টার্গেট হিসাবে তৈরি করছে, লুকানোর কোনও ভাল উপায় নয়)। এটি আমার প্রথম KOTH উত্তর, কেবলমাত্র rng বটকে পরাজিত করার প্রত্যাশায়।

Answer 14

সাইক্লার

এই বটটি কেবল তার মোড়ের প্রতিটি সংখ্যার মধ্য দিয়ে চক্র করে। কেবল মজাদার জন্য, এটি সূচকটি দিয়ে কাউন্টারটি আরম্ভ করে।

class Cycler(object):
  def __init__(self, index):
    self.counter = index # Start the count at our index
  def select(self):
    return self.counter + 1 # Add 1 since we need a number between 1-10
  def update(self, choices):
    self.counter = (self.counter + 1) % 10

Answer 15

এক ট্র্যাক মন

এই বটটি এলোমেলোভাবে একটি সংখ্যা বাছাই করে এবং এর সাথে 50 টি রাউন্ডের জন্য স্টিক করে, তারপরে অন্যটিকে বেছে নিয়ে পুনরাবৃত্তি করে।

import random

class OneTrackMind(object):
    def __init__(self, index):
        self.round = 0;
        self.target = random.randint(1,10)
    def select(self):
        return self.target
    def update(self, choices):
        self.round += 1;
        if self.round % 50 == 0:
            self.target = random.randint(1,10)

Answer 16

ভাগ্যবান সেভেন

class LuckySeven(object):
    def __init__(self, index):
        pass
    def select(self):
        return 7
    def update(self, choices):
        pass

আমি আজ নিজেকে ভাগ্যবান বোধ করছি! আমি 7 এ সব ফেলে দিচ্ছি!

Answer 17

আমার ধারণা হ'ল কৌশলগুলি বাস্তবের কৌশলগুলির প্রকৃত মূল্যায়নের চেয়ে বটের সংখ্যার উপর বেশি নির্ভরশীল।

উল্লেখযোগ্য সংখ্যক বট সহ, বিকল্পগুলি হ'ল:

• "লোভী" রোবটগুলি লক্ষ্য করে যে নিম্নমানের 1-3 নম্বর 10 বটগুলি "চতুর" এবং কম 1-3 নম্বর পাওয়ার লক্ষ্য রেখেছিল, সেই বটগুলিকে কেবল তাদের মধ্যে হস্তক্ষেপ করা দেওয়া ভাল।

• "স্মার্ট" রোবটগুলি যারা একবার বুঝতে পেরে 4 টি সর্বদা বাছাই করা হয় অন্য কোথাও চলে যাবে।

• "এলোমেলো" এবং "ধ্রুবক" রোবট। এখানে বেশি কিছু করার নেই।

সুতরাং, আমি # 4 তে বাজি ধরছি।

class LazyStalker(object):
    def __init__(self, index):
        pass
    def select(self):
        return 4
    def update(self, choices):
        pass

Answer 18

প্রয়োজনীয় আরএনজি বট

import secrets

class SecureRNG(object):
    def __init__(self, index):
        pass
    def select(self):
        return secrets.randbelow(10) + 1
    def update(self, choices):
        pass

Answer 19

গুপ্তঘাতক

ছায়ায় থাকা, তারপরে বর্তমান সর্বনিম্ন অনুমানের লক্ষ্য। চালান।

class Assassin(object):
    def __init__(self, index):
        self.index = index
        self.round = 0
        self.choices = [0]*10

    def select(self):
        if self.round == 0:
            return 10
        else:
            return min(self.choices)

    def update(self, choices):
        self.round += 1
        self.choices = choices
        self.choices[self.index] = 10

Answer 20

FollowBot

শেষ রাউন্ড থেকে বিজয়ীর অনুলিপি করুন, বা বিজয়ী না থাকলে সর্বনিম্ন সেরা ন্যূনতম-বাঁধা নির্বাচন।

import collections

class FollowBot(object):
    def __init__(self, index):
        self.lastround = []

    def select(self):
        counter = collections.Counter(self.lastround)
        counts = [(count,value) for (value,count) in counter.items()]
        counts.sort()
        if len(counts) >= 1:
            return counts[0][1]
        else:
            return 1

    def update(self, choices):
        self.lastround = choices

Answer 21

Psychadelic

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

class Psychadelic(object):
    def __init__(self, index):
        self.index = index
    def select(self):
        return random.randint(1, self.index + 1)
    def update(self, choices):
        pass

Answer 22

UnchosenBot

class UnchosenBot(object):
    def __init__(self, index):
        self.index = index
        self.answer = 0
    def select(self):
        if self.answer == 0:
            return 1
        return self.answer
    def update(self, choices):
        self.answer = 0
        del choices[self.index]
        for x in range(1, 11):
            if x not in choices:
                self.answer = x
                return

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

Answer 23

উচ্চ চিৎকার করা-Di-খবর-Di-গুলি চালানো

class WhoopDiScoopDiPoop(object):
    def __init__(self, index):
        self.index = index
        self.guess = 1
        self.tenure = 0
        self.perseverance = 4

    def select(self):
        return self.guess

    def update(self, choices):
        others = {c for i, c in enumerate(choices) if i != self.index}
        for i in range(1, self.guess):
            if i not in others:
                self.guess = i
                self.tenure = 0
                self.perseverance += 1
                return
        if self.guess not in others:
            self.tenure = 0
            return
        self.tenure += 1
        if self.tenure > self.perseverance:
            if self.guess == 10:
                return
            self.guess += 1
            self.tenure = 0

গুলি চালানো-Di-scoopty

class PoopDiScoopty(object):
    def __init__(self, index):
        self.index = index
        self.guess = 1
        self.tenure = 0
        self.perseverance = 4

    def select(self):
        return self.guess

    def update(self, choices):
        others = [c for i, c in enumerate(choices) if i != self.index]
        for i in range(1, self.guess):
            if i not in others:
                self.guess = i
                self.tenure = 0
                self.perseverance += 1
                return
        if self.guess not in others:
            self.tenure = 0
            return
        self.tenure += others.count(self.guess) # this is the change
        if self.tenure > self.perseverance:
            if self.guess == 10:
                return
            self.guess += 1
            self.tenure = 0

আমি পাইথনকে কখনও দেখিনি বা ছোঁয়াছি না, এটি কি অযৌক্তিক?

Comments

<!-- language: lang-python -->সিনট্যাক্স হাইলাইটিং সক্ষম করতে কোড ব্লকের আগে লাইনটি যুক্ত করুন

— হারম্যান এল

@ হারম্যানএল আমি pythonপ্রশ্নের একটি ট্যাগ হ্যালুসিনেট করেছিলাম এবং ভেবেছিলাম এটি স্বয়ংক্রিয় হবে তবে আমি খারাপ কিছু লিখেছি।

— মিহাইল মালোস্টানিডিস

পাইথোনিসিটির ক্ষেত্রে কোডটি বেশ ভাল, এটিকে বলা অজগরটিকে বিবেচনা না করা others = [c for i, c in enumerate(choices) if i != self.index], বা, কারণ পরবর্তীকালে আপনি কেবল সদস্যতার পরীক্ষার জন্য সেই পরিবর্তনশীলটি ব্যবহার { }না করে বরং [ ]একটি পরিবর্তনের জন্য তৈরি করেন । setlist

— রোমান ওডাইস্কি

if (self.guess)এটি খুব অযৌক্তিকও।

— জোনাথন ফ্রেচ 21

আমি জানি না যে এই চারপাশে পেরেনগুলি কীভাবে self.guessসেখানে প্রবেশ করেছিল! অবশ্যই বিন্যাসগুলির মধ্যে একটি হওয়া উচিত।

— মিহাইল মালোস্টানিডিস

Answer 24

ফোয়ারা

একটি সরল বট, সর্বনিম্ন সংখ্যাটি প্রথম পছন্দ করে এবং যদি অন্য কোনও বটও এটি চয়ন করে তবে এটি পাল্টাটি বাড়িয়ে দেবে - মেঝে ভরাট হয়ে যায় এবং জল নীচে প্রবাহিত হয়। যখন এটি 11 পৌঁছে যায়, এটি 1 এ পুনরায় আরম্ভ হয় - জলটি আবার শীর্ষে ফেলা হয়।

class Fountain:

    def __init__(self, index, target=10):

        # Set data
        self.index = index
        self.pick  = 1
        self.target = target+1

    def select(self):

        # Select the number
        return self.pick

    def update(self, choices: list):

        # Remove self from the list
        choices.pop(self.index)  # I hope `choices[:]` is passed, not `choices`.

        # While the selected number is occupied
        while self.pick in choices:

            # Pick next number
            self.pick += 1

            # If target was reached
            if self.pick == self.target:

                # Reset to 1
                self.pick = 1

Comments

এটির বর্তমান ফর্মে আপনার বটটি লুপের মধ্যে আটকে যাবে যদি অন্য বটগুলি 1 থেকে 8 পর্যন্ত সমস্ত সংখ্যা চয়ন করে থাকে তবে আপনি কি target10 এ সেট করতে চান?

— এমিল

@ এমিল সত্য, এটি মূলত এটির মতো ছিল, পরিবর্তিত হয়েছিল

— রেডক্লুভার

Answer 25

PoissonsBot

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

from numpy.random import poisson
import math

class PoissonsBot(object):
    def __init__(self, index):
        self.index = index
        self.mean = 2
        self.roundsleft = 1000

    def select(self):
        self.roundsleft = max(self.roundsleft-1, 2)
        return max(min(poisson(self.mean),10),1)

    def update(self, choices):
        myval = choices[self.index]
        nequal = len([c for c in choices if c==myval])
        nless = len([c for c in choices if c<myval])
        step = math.log10(self.roundsleft)
        if nequal > 1:
            self.mean += nequal/step
        self.mean -= nless/step
        self.mean = max(self.mean, 0.3)

Answer 26

MinWin

বিজয়ী মান এবং সর্বনিম্ন নির্বাচিত মানগুলির একটি চলমান গণনা রাখে (যেখানে সর্বনিম্ন নির্বাচিত মানটি কেবল বিজয়ী মানের চেয়ে কম হলে বিবেচিত হয়)। এটি এলোমেলোভাবে এই বিজয়ী এবং ন্যূনতম মানগুলির মধ্যে নির্বাচন করে।

import random

class MinWin:

    def __init__(self, index):
        self.index = index
        self.mins = list(range(1, 11))
        self.wins = list(range(1, 11))

    def select(self):
        return min(random.choice(self.mins), random.choice(self.wins))

    def update(self, choices):
        counts = [0] * 10
        for x in choices:
            counts[x - 1] += 1

        if 0 in counts and (1 not in counts or counts.index(0) < counts.index(1)):
            self.mins.append(counts.index(0) + 1)
        if 1 in counts:
            self.wins.append(counts.index(1) + 1)

Answer 27

PlayerCycle

খেলোয়াড়দের মাধ্যমে চক্র। বর্তমান প্লেয়ার (নিজেরাই হতে পারে) এর পছন্দ এখন এই বটের পছন্দ। 8 মুদ্রণ শুরু, কেন না। দুঃখিত আমি অজগর করতে পারি না, এটি সম্ভবত খারাপ কোড।

import itertools
class PlayerCycle(object):
    def __init__(self, index):
        self.a = itertools.cycle(range(10))
        self.b = 8
    def select(self):
        return self.b
    def update(self, choices):
        self.b = choices[next(self.a)]

সম্পাদনা: তাত্পর্য সহ আমার কোড উন্নত করার জন্য ট্রিগারনোমেট্রিকে ধন্যবাদ

Comments

আপনার কোডটি ঠিকঠাক কাজ করে, তবে আপনি একটি ইন্টারটোলস.সাইক্ল () যুক্ত করতে পারেন যাতে এটি স্বয়ংক্রিয়ভাবে 0-9-এর মধ্যে চক্র হয় এবং আপনাকে বর্ধন বা চেক করতে হয় না - অনলাইনে চেষ্টা করে দেখুন!

— ট্রিগারনমেট্রি

Answer 28

র্যাকুন

আমাদের নিজের আগের পছন্দ বাদে আগের রাউন্ডে না নির্বাচিত সর্বনিম্ন সংখ্যাটি বেছে নিন, যা এবার আবার বেছে নেওয়া যেতে পারে। প্রথম রাউন্ডে, 1 টি নির্বাচন করুন (9 টি প্রতিপক্ষ এবং 10 টি পছন্দ দেওয়া হয়েছে, এটির জন্য একটি উপলভ্য মান হওয়ার নিশ্চয়তা রয়েছে))

আমি স্বাধীনভাবে এটি নিয়ে এসেছি, তবে এখন কমপক্ষে 2 টি পূর্বের বটগুলি দেখুন যা মূলত একই।

class Raccoon(object):
    def __init__(self, index):
        self.index = index
        self.last_round = None
        self.domain = None
    def select(self):
        # Return the lowest number not chosen last time.
        if self.domain is None:
            return 1
        else:
            # This finds the smallest element of domain, not present in last_round
            return min(self.domain-self.last_round)
    def update(self, choices):
        last_round = choices[:]
        last_round[self.index] = 0 # don't include our own choice
        self.last_round = set(last_round)
        if self.domain is None:
            self.domain = set(range(1,len(choices)+1))

র্যাকুন ত্রিভুজ

র্যাকুন এবং ত্রিভুজ একত্রিত: অচেনা মান থেকে, বিপরীত ত্রিভুজ সম্ভাবনার উপর ভিত্তি করে একটি চয়ন করুন।

import random
class RaccoonTriangle(object):
    def __init__(self, index):
        self.index = index
        self.unchosen = set([1,])
        self.domain = None
    def select(self):
        # Return the lowest number not chosen last time.
        if self.domain is None:
            return random.randint(1,self.index+1)
        else:
            # Reverse triangle weights for unchosen values
            weighted_choices = [u for i,u in enumerate(sorted(self.unchosen),0) for _ in range(len(self.unchosen)-i)]
            return random.choice(weighted_choices)
    def update(self, choices):
        last_round = choices[:] # make a copy
        last_round[self.index] = 0 # don't include our own choice
        if self.domain is None:
            self.domain = set(range(1,len(choices)+1))
        self.unchosen = self.domain - set(last_round)

Comments

ত্রুটি:AttributeError: 'RaccoonTriangle' object has no attribute 'boundaries'

— রেঞ্জি

হ্যা দুঃক্ষিত. আমি মনে করি আমি এটি ঠিক করেছি। আমি পরীক্ষার লেখার মাঝখানে ছিলাম, যখন আমি ছাড়ি left

— কোয়ান্টাম মেকানিক

Answer 29

সাধারণ

সাধারণ সবসময় শেষ যুদ্ধ মারামারি (গুলি) ।

import numpy
import random

class TheGeneral:
    def __init__(self, index):
        self.round = 0
        self.index = index
        self.would_have_won = [0] * 10

    def select(self):
        if self.round <= 100:
            return random.choice((list(numpy.nonzero(self.would_have_won)[0]) + [0, 1])[:2]) + 1

        return random.choice(numpy.argsort(self.would_have_won)[-2:]) + 1

    def update(self, choices):
        for i, s in enumerate(numpy.bincount([c - 1 for i, c in enumerate(choices)
            if i != self.index], minlength=10)):

            if s == 0:
                self.would_have_won[i] += 1
            elif s == 1:
                break

        self.round += 1

Answer 30

না পুনরাবৃত্তি র্যান্ডম

import secrets

class NoRepeats(object):
    def __init__(self, index):
        self.lastround = secrets.randbelow(10) + 1

    def select(self):
        i = secrets.randbelow(10) + 1
        while i == self.lastround:
             i = secrets.randbelow(10) + 1
        self.lastround = i
        return self.lastround

    def update(self, choices):
        pass

বট এলোমেলোভাবে বাছাই করে তবে এটি আগের রাউন্ডের মতো একই সংখ্যাটি বেছে নেওয়া এড়ানো যায়।