ПРИМІТКА : Переможець цього змагання - Джек !!!. Більше жодних заявок не приймається.

Ось балачка для цього виклику королівства . Це мій перший, тому я відкритий для пропозицій!

Жнець - це ігрова концепція, розроблена мистецтвом вирішення проблем, яка передбачає терпіння та жадібність. Змінивши гру, щоб вона підходила до змагань у стилі KOTH (Дякую @NathanMerrill та @dzaima за ваші пропозиції та вдосконалення), ось це завдання.

Гра працює наступним чином: у нас є значення, відоме як Reap, що множиться на задану константу кожного галочки. Після кожного галочки кожен бот має можливість "пожинати", що означає додавання поточного значення Reap до своєї оцінки та зменшення Reap до 1.

Однак є фіксована кількість кліщів, яких бот повинен чекати між «жнетами», і фіксованою кількістю очок, необхідних для виграшу гри.

Досить просто? Ось ваші входи:

I / O

Ви повинні написати функцію в Python 3, яка займає 3 входи. Перший selfвикористовується для посилання на об'єкти класу (показано далі). Друга - це Reap, поточне значення Жнива, яке ви заробляли, якби «пожинати». Третя - prevReapсписок ботів, які пожинали під час попереднього галочки.

Інші об'єкти, до яких можна отримати доступ у своїй функції:

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

Ви НЕ МОЖЕТЕ редагувати будь-який вміст цих об'єктів, за винятком self.obj.

Ви повинні вивести, 1щоб пожинати, і що-небудь інше (або нічого), щоб не пожинати. Зауважте, що якщо ви пожинете, коли не чекали достатньо кліщів, я проігнорую той факт, що ви вирішили пожинати.

Правила

Параметри я буду використовувати це winning_score=10000, multiplier=1.6-(1.2/(1+sqrt(x))), waittime = floor(1.5*x)де xця кількість ботів в Koth.

• Гра закінчується, коли гравець (або декілька) досягає виграшного балу.
• Коли кілька ботів просять отримати пожинання одночасно, пріоритет надається ботам, які чекали довше (у разі зв’язків, ботам, які дочекалися максимуму часу, все дозволяється пожинати та набирати очки в Reap)
• Ваш бот повинен у середньому займати не більше 100 мс протягом 5 кліщів.
• Якщо ви хочете імпортувати бібліотеки, запитайте! Я спробую додати будь-які бібліотеки, які я можу запустити у моїй настільній версії Python (математика вже імпортна: не соромтеся використовувати її)
• Усі стандартні лазівки для KoTH, такі як дублюючі боти, 1-боти тощо, забороняються аналогічно.
• Будь-які боти, які використовують будь-яку випадковість, повинні використовувати getRandomфункцію, яку я надав.

Ви можете знайти контролер за посиланням TIO нижче. Щоб скористатися ним, додайте ім'я своєї функції у BotListвигляді рядка, а потім додайте функцію до коду. Змініть, multiplierщоб змінити те, що Reap множиться на кожну галочку, модифікуйте, winning_scoreщоб змінити рахунок, необхідний для завершення гри, і модифікуйте, waittimeщоб змінити кількість тиків, щоб чекати між жнетами.

Для вашої зручності, ось кілька зразкових (і досить нерозумних) ботів. Надсилання ботів, подібних до цих, забороняється. Однак вони демонструють, як працює контролер.

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

Для тих, хто цікавиться, ось контролер з 15 вбудованими в нього матеріалами: Спробуйте в Інтернеті

ЗВІТНІ РЕЗУЛЬТАТИ

ВОЛО ТОМУ НАРОДНО ТУТ! Перевірте посилання TIO вище, щоб побачити, який код я використав для генерації підсумкових таблиць. Результати не страшно цікаві. За 1000 пробіжок, які я робив з різними випадковими насінням, результати були

1000 wins - Jack
0 wins - everyone else

Вітаємо переможця Баунті Джека !! (він же @Renzeee)

Нерішучий тужливий безлад

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

Цей бот спочатку робить звичайні перевірки (чи можу я пожинати, чи можу я виграти?), А потім шукає цільове значення, перш ніж він пожинає. Однак він нерішучий, тому після досягнення цілі він задається питанням, скільки ще часу може чекати, і не збирається отримати відразу. Крім того, він смикає, тому може випадково «натиснути кнопку» і поповнити перед ціллю.

Веселий факт: Це, в основному, те, як я граю жнивою як людина.

Снайпер

Бот, що підживлюється на злості. Відстежує затримки та результати забиття суперника. Спроби утримати перемогу інших. Насправді ніколи насправді не виграє, але змушує гру неприємно грати для інших.

Редагувати:

• Якщо жниво призведе до перемоги, пожинайте.

• Якщо ніхто не складає = = 70% виграшного бала:

  • Якщо всі інші перестали працювати, дочекайтеся останнього можливого моменту, щоб знову скористатися.
  • Якщо хтось інший виграє, отримавши поточне значення, і вони активні зараз або будуть активні наступного повороту, пожинайте.
  • Якщо принаймні половина інших користувачів перервана, спробуйте скористатися. Це ускладнює націлювання на конкретних супротивників, і це було усунено.
  • В іншому випадку пожинайте 25% часу (по суті, щоб гарантувати, що цей бот пожинає САМОТИМИ, на всякий випадок, якщо трапиться щось дивне, як усі чекають кілька витків).

• Якщо хтось ІС> = 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

Нудно

Просто для розваги, цього бота приніс друг і насправді не хоче бути тут. Вони прокатують d16, поки не отримають число в 1-9, потім намагаються ввести в будь-який час, коли число містить обрану цифру. (Якщо піти шукати d10, то це зірве гру, яка груба, а 0 просто занадто просто!)

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

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

        self.obj.fav_int = r

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

    # default return: do not reap
    return 0

Джек

Це простий бот з 4 правилами:

• Не пожинайте, коли це нічого не робить
• Завжди пожинайте, коли пожинати, дозволяє нам виграти
• Також пожинайте, коли не було пожинало 3 кліща
• Інакше нічого не робити

Я оптимізував 3 тика в порівнянні з існуючими ботами (Sniper, grim_reaper, Every50, безлад, BetterRandom, Averager і деякі інші).

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 кліщів), але також пожинайте, якщо ви не пожинали довше, ніж X тиків, а потім пожинаєте після того, як було пропущено менше кліщів під час нежиті (тобто 5, якщо чекати довше, ніж я . Waittime + 5, також пожинайте, якщо не отримали 4 кліща). Але це не покращилося, просто завжди пожинаючи 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.

Як бачите, вона досягає вище 50 після 13 кліщів. Так як Reapбуде скинуто на 1 кожен раз , коли бот тисне, а waittimeдля робота , який тисне на 37, ймовірність того, бот тисне раніше , ніж пізніше досить високо, особливо з ботами , схожими на приклад GreedyBot, який буде жати , як тільки їх waittimeIS доступний знову. Спочатку я хотів зробити 200, що є 17-м тиком, дещо посеред 37-х тиків часу очікування, але при припущенні, що в грі є 25 ботів, є досить високий шанс, що хтось інший вирве Reapперед мною. Тож я знизив його до 50. Це все-таки приємне округлене число, але тим більше, що це 13-ий галочок (з 25 ботами), а 13 і «пожинання» також трохи вписуються в той самий «злий» жанр.

Код:

Код тривіальний.

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

Примітки:

Цей бот досить поганий з низькою кількістю ботів у грі. Поки що я залишу це, і я можу зробити кращого бота, фактично підрахувавши найкращий час Reap. З надзвичайно низькою кількістю ботів у грі waittimeнабагато нижче, так що, навіть, GreedyBotви можете виграти цього бота, якщо той waittimeдосить низький.

Сподіваємось, більше людей додадуть набагато більше ботів. ; стор

Посередник

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

Цей бот намагається отримати будь-який час, коли поточне значення Reap перевищує середнє значення Reaped.

Похмурий Жнець

Цей бот зберігає середнє значення значень усіх попередніх пожитків, а також часу, коли кожен бот чекав. Він пожинає, коли чекав довше, ніж 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

Редагувати: виправлено деякі бентежні синтаксичні помилки.

Спробуйте в Інтернеті

BetterRandom

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

Бот ґрунтується на припущенні, що шанс пожинати повинен бути пропорційний розміру пожинання, оскільки точка - це точка, незалежно від того, коли вона отримана. Завжди є дуже малий шанс скотитися, це підтримує поведінку в експлуатації. Спершу я подумав, що це буде прямо пропорційним, і припустив, що константа пропорційності буде навколо 1/mult^waittime(максимальний пожиток, якщо принаймні один бот грає жадібно) після запуску деяких симуляцій, я виявив, що це справді оптимальна константа. Але бот все ще перевершував Random, тому я зробив висновок, що відношення не було прямо пропорційним і додав константу для обчислення того, що таке відношення. Після деяких симуляцій я виявив, що проти мого тестового набору -1.5було оптимально. Це фактично відповідає обернено пропорційним співвідношенням між шансом пожинання таreap*sqrt(reap)що дивно. Тому я підозрюю, що це сильно залежить від конкретних ботів, тому версія цього бота, яка обчислює k під час гри, буде кращою. (Я не знаю, чи дозволено вам використовувати дані з попередніх раундів).

EDIT: Я зробив програму, щоб автоматично знайти вид пропорційності. На тестовому наборі ["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"]я знайшов нове значення.

Ціль

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

Мої шанси на перемогу з безладом зараз майже відсутні, тож час зіпсувати всіх інших ботів якомога більше способів! :)

Цей бот функціонує схоже на снайперський. Щоразу, коли хтось пожинає, він вибирає випадкову ціль у того, хто пожив. Тоді вона просто чекає, поки ціль майже не зможе знову отримати її та обрізає. Однак це не змінює фокус - після того, як вас вибрали та заблокували, ви не можете уникнути :)

EveryN

Я здогадуюсь, що настав час для мого другого бота прямо до встановленого терміну.

Цей бот:

• Пропустіть, коли ще залишається час очікування останнього жніва
• Пожинайте, коли це може виграти
• Пожинайте, коли ніхто не пожинав принаймні nраунди, де nобчислюєтьсяn = 3 + ceil(self.waittime / self.lenBots)

Код:

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

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

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

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

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

    return 0

Я не програмую в Python дуже часто, тому, якщо ви бачите якісь помилки, дайте мені знати.

Триває: Мій проект поширити 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

Середній Джо

Я надихнувся Averager і створив бота, який підраховує в середньому, скільки оборотів проходить, перш ніж хтось пожинає і намагається скористатися одним оборотом до цього.

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

HardCoded

Так.

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

Замість того, щоб усереднювати минулі пожинки, використовуйте попередньо обчислене середнє значення для типового пробігу. З часом все одно не покращиться.