注意：本比赛的获胜者是杰克！不再接受任何提交。

这是应对挑战之王的聊天室。这是我的第一个，所以我很愿意提出建议！

“收割者”是由“解决问题的艺术”开发的一种游戏概念，涉及耐心和贪婪。在修改了游戏以适应KOTH风格的比赛之后（感谢@NathanMerrill和@dzaima的建议和改进），这就是挑战。

游戏的工作原理如下：我们有一个称为Reap的值，该值在每个刻度线内乘以给定的常数。每次滴答之后，每个漫游器都可以选择“收获”，这意味着将Reap的当前值添加到一个人的分数中，并将Reap降低到1。

但是，机器人必须在“收割”之间等待一定数量的滴答声，而赢得游戏所需的点数也必须固定。

很简单？这是您的输入：

输入输出

您将在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机器人的数量。

• 当一个或多个玩家达到获胜分数时，游戏结束。
• 当多个机器人要求一次收割时，将优先考虑等待时间更长的机器人（在平局的情况下，等待最长时间的所有机器人都可以收割并获得收割中的积分）
• 您的机器人在5个滴答声中平均花费的时间不得超过100毫秒。
• 如果要导入库，请询问！我将尝试添加可在桌面版Python上运行的所有库（已经导入了数学：可以随时使用它）
• 同样，禁止使用KoTH的所有标准漏洞，例如重复的bot，1-up bot等。
• 任何使用任何随机性的漫游器都必须使用getRandom我提供的功能。

您可以在下面的TIO链接中找到控制器。若要使用它，请将函数的名称添加BotList为字符串，然后将函数添加到代码中。修改multiplier以更改收割乘以每个刻度的收益，修改winning_score以更改结束游戏所需的分数，并修改waittime以更改在两次收割之间等待的滴答数。

为了方便起见，这里有一些示例（相当愚蠢的）机器人。不允许提交与这些机器人类似的机器人。但是，它们演示了控制器的工作方式。

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

对于那些感兴趣的人，这里是Controller并内置了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％的时间（本质上是为了确保此机器人确实能够在某些时候获得收益，以防万一发生奇怪的事情，例如每个人都在等待几圈）。

• 如果某人的IS> =获胜分数的70％：

  • 如果狙击手可以赢得决胜局，并且下一轮得分高于得分最高的对手的平均收割值，
  • 如果得分最高的对手下一回合将离开冷却时间，则收获。

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

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

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

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

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

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

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

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

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

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

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

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

            ):
                return 1

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

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

    # default return: do not snipe
    return 0

无聊

只是为了好玩，这个机器人是由一位朋友带来的，实际上并不想在这里。他们滚动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刻时也收获
• 否则什么都不做

我相对于当前的现有机器人（狙击手，grim_reaper，Every50，混乱，BetterRandom，Averager等）优化了3个刻度。

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

我尝试使用我的旧解决方案（5个滴答声），但如果您收割的时间没有超过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.

如您所见，它在经过13个滴答之后达到了50以上。由于Reap将每一次复位为1一个机器人收割，并且waittime对于一个机器人即收割是37，可能迟早一个机器人收割是相当高的，尤其是与机器人类似于示例GreedyBot，这将立即收获它们waittime就是再次可用。起初我想做200，这是第17个滴答声，大约在37个等待时间滴答声的中间，但是假设有25个机器人在玩，那么其他人抢夺Reap我的机会就很高。所以我将其降低到50。它仍然是一个不错的四舍五入数字，但是特别是因为它是第13个滴答（带有25个漫游器），而13和“收获”也属于同一“邪恶”类型。

码：

该代码是可笑的琐碎。

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

笔记：

该机器人在玩的机器人数量很少时非常糟糕。现在，我将离开它，并且我可能会让一个更好的机器人实际计算出的最佳时间Reap。waittime当然，在玩的机器人数量非常少的情况下，机器人的数量也要低得多，因此，GreedyBot如果机器人waittime数量足够低，甚至可能很容易从该机器人中获胜。

希望更多的人会添加更多的机器人。; p

平均器

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值，该机器人就会尝试收割。

死神

该机器人保持所有先前收割值以及每个机器人等待时间的运行平均值。当它等待的时间超过其他bot的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

编辑：修复了一些令人尴尬的语法错误。

在线尝试

更好的随机

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的版本会更好。（但是我不知道是否允许您使用前几轮的数据）。

编辑：我做了程序来自动查找比例类型。在测试集上，["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

我现在用混乱赢得胜利的机会几乎不存在，所以有时间以尽可能多的方式弄乱所有其他机器人！:)

该机器人的功能类似于狙击手。每当有人收割时，它都会从收割者中随机选择目标。然后，它只是等待直到该目标几乎可以再次收获并剪断它。但是，它不会改变焦点-一旦选择并锁定您，就无法逃脱:)

每个N

我想现在是我第二个机器人在截止日期之前的时候了。

该机器人将：

• 仍在等待上一次收割的时间时跳过
• 可以赢时收获
• 如果没有人至少收获了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扩展到每个开放的KOTH。

针锋相对

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

硬编码

是的。

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

无需对过去的收入进行平均，而是在典型运行中使用预先计算的平均值。无论如何，时间不会变得更好。