LƯU Ý : Người chiến thắng trong cuộc thi này là Jack !!!. Không có nhiều bài nộp sẽ được chấp nhận.

Đây là phòng trò chuyện cho thử thách vua đồi này . Đây là lần đầu tiên của tôi vì vậy tôi mở để đề xuất!

Reaper là một khái niệm trò chơi được phát triển bởi Nghệ thuật giải quyết vấn đề liên quan đến sự kiên nhẫn và tham lam. Sau khi sửa đổi trò chơi để phù hợp với một cuộc thi theo phong cách KOTH (Cảm ơn @NathanMerrill và @dzaima vì những gợi ý và cải tiến của bạn), đây là một thách thức.

Trò chơi hoạt động như sau: chúng tôi có một giá trị được gọi là Reaper nhân với một hằng số cho trước mỗi tích tắc. Sau mỗi lần đánh dấu, mỗi bot có tùy chọn "gặt hái", điều đó có nghĩa là thêm giá trị hiện tại của Reaper vào điểm số của một người, và giảm xuống còn 1.

Tuy nhiên, có một số tích tắc cố định mà bot phải đợi ở giữa "gặt" và một số điểm cố định cần thiết để giành chiến thắng trong trò chơi.

Đủ đơn giản? Đây là đầu vào của bạn:

Tôi / O

Bạn phải viết một hàm trong Python 3 có 3 đầu vào. Đầu tiên là self, được sử dụng để tham chiếu các đối tượng lớp (hiển thị sau). Thứ hai là Reap, giá trị hiện tại của Reaper mà bạn sẽ kiếm được nếu bạn "gặt hái". Thứ ba là prevReap, một danh sách các bot đã gặt hái trong lần đánh dấu trước.

Các đối tượng khác bạn có thể truy cập trong chức năng của mình:

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.

Bạn PHẢI không chỉnh sửa bất kỳ nội dung nào của các đối tượng này, ngoại trừ self.obj.

Bạn phải xuất ra 1để gặt, và bất cứ điều gì khác (hoặc không có gì) để không gặt. Lưu ý rằng nếu bạn gặt hái khi bạn chưa đợi đủ số lần đánh dấu, tôi sẽ bỏ qua thực tế là bạn đã chọn để gặt hái.

Quy tắc

Các thông số tôi sẽ sử dụng được winning_score=10000, multiplier=1.6-(1.2/(1+sqrt(x))), waittime = floor(1.5*x)nơi xlà số chương trình trong KOTH.

• Trò chơi kết thúc khi một người chơi (hoặc nhiều người) đạt được số điểm chiến thắng.
• Khi nhiều bot yêu cầu gặt hái cùng một lúc, ưu tiên dành cho các bot đã chờ đợi lâu hơn (trong trường hợp có quan hệ, các bot đã đợi thời gian tối đa, tất cả đều được phép gặt hái và đạt được điểm trong Reaper)
• Bot của bạn phải mất trung bình không quá 100 ms trên 5 tick.
• Nếu bạn muốn nhập thư viện, hãy hỏi! Tôi sẽ cố gắng thêm bất kỳ thư viện nào tôi có thể chạy trên phiên bản Python trên máy tính để bàn của mình (toán học đã được nhập: hãy sử dụng nó)
• Tất cả các lỗ hổng tiêu chuẩn cho KoTH, chẳng hạn như bot trùng lặp, bot 1-up, v.v., đều bị cấm tương tự.
• Bất kỳ bot nào sử dụng bất kỳ loại ngẫu nhiên nào cũng phải sử dụng getRandomchức năng tôi đã cung cấp.

Bạn có thể tìm thấy bộ điều khiển trong liên kết TIO bên dưới. Để sử dụng nó, hãy thêm tên hàm của bạn BotListthành một chuỗi, sau đó thêm hàm vào mã. Sửa đổi multiplierđể thay đổi số điểm được nhân với mỗi lần đánh dấu, sửa đổi winning_scoređể thay đổi số điểm cần thiết để kết thúc trò chơi và sửa đổi waittimeđể thay đổi số lượng bọ để chờ giữa các lần gặt.

Để thuận tiện cho bạn, đây là một số bot mẫu (và khá ngớ ngẩn). Gửi các bot tương tự như thế này sẽ không được phép. Tuy nhiên, họ chứng minh cách thức hoạt động của bộ điều khiển.

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

Đối với những người quan tâm, đây là Bộ điều khiển với 15 bài nộp được tích hợp sẵn: Dùng thử trực tuyến

KẾT QUẢ CUỐI CÙNG

WOO THEY LÀ CUỐI CÙNG TẠI ĐÂY! Kiểm tra Liên kết TIO ở trên để xem mã nào tôi đã sử dụng để tạo bảng xếp hạng cuối cùng. Kết quả không thú vị lắm. Hơn 1000 lần chạy tôi đã làm với các hạt ngẫu nhiên khác nhau, kết quả là

1000 wins - Jack
0 wins - everyone else

Xin chúc mừng người chiến thắng Bounty Jack !! (còn gọi là @Renzeee)

Twitchy lộn xộn

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

Bot này thực hiện kiểm tra thông thường trước tiên (Tôi có thể gặt hái được không, tôi có thể giành chiến thắng không?) Và sau đó tìm kiếm một giá trị mục tiêu trước khi nó gặt hái. Tuy nhiên, nó thiếu quyết đoán, vì vậy sau khi nó đạt được mục tiêu, nó tự hỏi nó có thể chờ đợi bao lâu nữa và không gặt hái được ngay lập tức. Ngoài ra, nó rất khó xử, vì vậy nó có thể vô tình "nhấn nút" và gặt hái trước mục tiêu.

Sự thật thú vị: Về cơ bản, đây là cách tôi chơi máy gặt như một con người.

Kẻ bắn tỉa

Một bot được thúc đẩy bởi spite. Theo dõi thời gian hồi chiêu và điểm số của đối thủ. Nỗ lực để giữ cho người khác chiến thắng. Khá nhiều không bao giờ thực sự chiến thắng, nhưng làm cho trò chơi bực bội để chơi cho người khác.

BIÊN TẬP:

• Nếu gặt sẽ làm cho nó thắng, gặt.

• Nếu không có ai> = 70% số điểm chiến thắng:

  • Nếu mọi người khác đang ở trong thời gian hồi chiêu của họ, hãy đợi đến giây phút cuối cùng có thể để gặt hái.
  • Nếu bất cứ ai khác sẽ giành chiến thắng bằng cách gặt hái giá trị hiện tại và họ đang hoạt động ngay bây giờ hoặc sẽ hoạt động vào lượt tiếp theo, hãy gặt hái.
  • Nếu ít nhất một nửa số người dùng khác đang trong thời gian hồi chiêu, hãy cố gắng gặt hái. Điều này gây khó khăn cho việc nhắm mục tiêu đối thủ cụ thể, và vì vậy đã bị loại bỏ.
  • Mặt khác, gặt hái 25% thời gian (về cơ bản để đảm bảo rằng bot này gặt hái SOMETIMES, trong trường hợp có điều gì đó kỳ lạ xảy ra, như mọi người đang chờ đợi nhiều lượt).

• Nếu ai đó IS> = 70% số điểm chiến thắng:

  • Nếu Sniper có thể giành được một breakbreaker, và vòng tiếp theo sẽ cao hơn giá trị trung bình của Reaper cho đối thủ có điểm cao nhất, gặt hái
  • Nếu đối thủ ghi điểm cao nhất sẽ rời khỏi thời gian hồi chiêu tiếp theo, hãy gặt hái.

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

Chán

Chỉ để cho vui, bot này được một người bạn mang theo và không thực sự muốn ở đây. Họ cuộn một d16 cho đến khi họ nhận được một số trong 1-9, sau đó họ cố gắng gặt hái bất cứ lúc nào một số có chứa chữ số đã chọn. (Việc tìm kiếm một d10 sẽ phá vỡ trò chơi, điều này thật thô lỗ và 0 thì quá dễ dàng!)

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

Jack

Đây là một bot đơn giản với 4 quy tắc:

• Đừng gặt hái khi nó không làm gì cả
• Luôn gặt hái khi gặt hái cho phép chúng tôi giành chiến thắng
• Cũng gặt khi chưa gặt được 3 tích tắc
• Nếu không thì không làm gì cả

Tôi đã tối ưu hóa 3 đánh dấu so với các bot hiện tại (Sniper, grim_reaper, Every50, mess, BetterRandom, Averager, một số chi tiết khác).

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

Tôi đã cố gắng ở lại với giải pháp cũ của mình (5 tick) nhưng cũng gặt hái nếu bạn không gặt được lâu hơn tick X, và sau đó gặt hái sau khi ít tick hơn được truyền trong khi không gặt (tức là 5, nếu chờ lâu hơn bản thân .waittime + 5, cũng gặt nếu không được gặt trong 4 tích tắc). Nhưng điều này không cải thiện chỉ luôn gặt hái sau 4 tích tắc thay vì 5.

Cứ 50

Bot này sẽ gặt hái mỗi khi Reapsố tiền trên 50.

Tại sao 50?

Nếu tôi đưa ra giả định sẽ có 25 bot đang chơi, điều đó có nghĩa là multiplier = 1.6-(1.2/(1+sqrt(25))) = 1.4và waittime = floor(1.5*25) = 37. Kể từ khi Reapbắt đầu 1, nó sẽ tăng lên như thế này:

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.

Như bạn có thể thấy, nó đạt trên 50 sau 13 tích tắc. Kể từ khi Reapsẽ thiết lập lại để 1 mỗi khi một bot gặt, và waittimecho một bot mà gặt là 37, khả năng một bot gặt sớm hơn sau này là khá cao, đặc biệt là với chương trình tương tự như ví dụ GreedyBot, sẽ gặt hái càng sớm càng của họ waittimelà có sẵn một lần nữa. Lúc đầu, tôi muốn thực hiện 200 con bọ thứ 17, phần nào ở giữa 37 con bọ thời gian chờ đợi, nhưng với giả định có 25 con bot đang chơi thì có khả năng rất cao có người khác giật lấy Reaptôi. Vì vậy, tôi đã hạ nó xuống 50. Đây vẫn là một con số tròn đẹp, nhưng đặc biệt là vì nó là con số thứ 13 (với 25 bot), và 13 và 'gặt hái' cũng phù hợp với thể loại 'ác' tương tự.

Mã số:

Các mã là đáng cười ..

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

Ghi chú:

Bot này là khá xấu với số lượng bot thấp trong chơi. Bây giờ tôi sẽ rời khỏi nó, và tôi có thể làm cho một bot tốt hơn thực sự tính toán thời gian tốt nhất để Reap. Với số lượng bot cực kỳ thấp waittime, dĩ nhiên là thấp hơn rất nhiều, do đó, thậm chí GreedyBotcó thể giành chiến thắng khá dễ dàng từ bot này nếu waittimeđủ thấp.

Hy vọng nhiều người sẽ thêm nhiều bot hơn. ; p

Trung bình

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

Bot này cố gắng gặt hái bất cứ lúc nào giá trị hiện tại của Riệp cao hơn giá trị trung bình.

Thần chết

Bot này giữ trung bình hoạt động của các giá trị của tất cả các lần gặt trước đó cũng như thời gian mỗi bot đã chờ đợi. Nó gặt hái khi nó đã chờ đợi lâu hơn 3/4 các bot khác và gặt hái ít nhất bằng 3/4 kích thước của gặt trung bình được thấy cho đến nay. Mục tiêu là lấy được nhiều gặt hái có kích thước hợp lý, rủi ro thấp.

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

Chỉnh sửa: Đã sửa một số lỗi cú pháp lúng túng.

Dùng thử trực tuyến

BetterRandom

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

Bot dựa trên giả định rằng cơ hội gặt hái phải tỷ lệ thuận với kích thước gặt vì một điểm là một điểm, bất kể khi nào nó nhận được. Luôn luôn có một cơ hội rất nhỏ để gặt hái, điều này giữ cho hành vi có thể khai thác. Đầu tiên tôi nghĩ rằng nó sẽ tỷ lệ thuận và giả định hằng số tỷ lệ xung quanh là điều đáng ngạc nhiên. Vì vậy, tôi nghi ngờ điều này phụ thuộc nhiều vào các bot cụ thể nên một phiên bản của bot này tính k trong khi chơi sẽ tốt hơn. (Nhưng tôi không biết liệu bạn có được phép sử dụng dữ liệu từ các vòng trước không).1/mult^waittime (gặt tối đa giả sử ít nhất một bot chơi tham lam) sau khi chạy một số mô phỏng tôi thấy rằng đây thực sự là hằng số tối ưu. Nhưng bot vẫn vượt trội so với Random nên tôi kết luận mối quan hệ không tỷ lệ thuận và thêm một hằng số để tính toán mối quan hệ là gì. Sau một số mô phỏng tôi thấy rằng đối với bộ bot thử nghiệm của tôi -1.5là tối ưu. Điều này thực sự tương ứng với một mối quan hệ tỷ lệ nghịch giữa cơ hội gặt hái vàreap*sqrt(reap)

EDIT: Tôi đã thực hiện chương trình để tìm loại tỷ lệ tự động. Trên bộ kiểm tra["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"] tôi tìm thấy giá trị mới.

Mục tiêu

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

Cơ hội chiến thắng với mớ hỗn độn của tôi gần như không có, vì vậy thời gian để làm rối tung tất cả các bot khác theo nhiều cách nhất có thể! :)

Bot này có chức năng tương tự như bắn tỉa. Bất cứ khi nào ai đó gặt hái, nó chọn một mục tiêu ngẫu nhiên từ bất cứ ai gặt hái. Sau đó, nó chỉ đơn giản là đợi cho đến khi mục tiêu đó gần như có thể gặt lại và bắn tỉa nó. Tuy nhiên, nó không thay đổi trọng tâm - một khi bạn đã được chọn và khóa, bạn không thể thoát :)

Mọi người

Tôi đoán đó là thời gian cho bot thứ hai của tôi ngay trước thời hạn.

Bot này sẽ:

• Bỏ qua khi nó vẫn còn trong thời gian chờ đợi cho lần cuối cùng
• Khi nào nó có thể thắng
• Khi mà không ai gặt hái được ít nhất là trong các nvòng, nđược tính bằngn = 3 + ceil(self.waittime / self.lenBots)

Mã số:

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

Tôi không lập trình bằng Python rất thường xuyên, vì vậy nếu bạn thấy bất kỳ lỗi nào hãy cho tôi biết.

Đang thực hiện: Dự án của tôi để mở rộng T4T cho mọi KOTH mở.

Tít cho tất

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

Tít cho n Tats

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

Kevin

Chỉ để giữ cho bạn trên ngón chân của bạn.

def kevin(just, a, joke):
    return 0

Joe trung bình

Tôi lấy cảm hứng từ Averager và tạo ra một bot tính trung bình bao nhiêu lượt trước khi ai đó gặt hái và cố gắng gặt hái một lượt trước đó.

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

HardCoding

Vâng, đúng vậy.

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

Thay vì tính trung bình trên các gặt quá khứ, hãy sử dụng mức trung bình được tính toán trước trên một lần chạy thông thường. Dù sao nó cũng sẽ không tốt hơn với thời gian.