CATATAN : Pemenang kompetisi ini adalah Jack !!!. Tidak ada lagi kiriman yang akan diterima.

Ini adalah ruang obrolan untuk tantangan king-of-the-hill ini . Ini adalah yang pertama saya jadi saya terbuka untuk saran!

Reaper adalah konsep permainan yang dikembangkan oleh Art of Problem Solving yang melibatkan kesabaran dan keserakahan. Setelah memodifikasi game agar sesuai dengan kontes gaya KOTH (Terima kasih kepada @NathanMerrill dan @dzaima atas saran dan peningkatan Anda), inilah tantangannya.

Gim berfungsi sebagai berikut: kami memiliki nilai yang dikenal sebagai Menuai yang dikalikan dengan konstanta yang diberikan setiap centang. Setelah setiap kutu, setiap bot memiliki opsi "menuai", yang berarti menambahkan nilai saat ini dari Reap ke skor seseorang, dan mengurangi menuai ke 1.

Namun, ada sejumlah kutu yang harus ditunggu oleh bot di antara "menuai", dan sejumlah poin tetap yang diperlukan untuk memenangkan permainan.

Cukup sederhana? Berikut masukan Anda:

I / O

Anda harus menulis fungsi dengan Python 3 yang membutuhkan 3 input. Yang pertama adalah self, digunakan untuk referensi objek kelas (ditampilkan nanti). Yang kedua adalah Reap, nilai saat ini dari Menuai yang akan Anda peroleh jika Anda ingin "menuai". Yang ketiga adalahprevReap , daftar bot yang menuai selama centang sebelumnya.

Objek lain yang dapat Anda akses di fungsi Anda:

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.

Anda HARUS tidak mengedit konten dari objek-objek ini, kecuali untukself.obj .

Anda harus keluar 1untuk menuai, dan apa pun (atau tidak sama sekali) untuk tidak menuai. Perhatikan bahwa jika Anda menuai ketika Anda belum cukup menunggu kutu, saya akan mengabaikan fakta bahwa Anda telah memilih untuk menuai.

Aturan

Parameter saya akan menggunakan yang winning_score=10000, multiplier=1.6-(1.2/(1+sqrt(x))), waittime = floor(1.5*x)di mana xadalah jumlah bots di Koth.

• Permainan berakhir ketika seorang pemain (atau beberapa) mencapai skor kemenangan.
• Ketika beberapa bot meminta untuk menuai sekaligus, prioritas diberikan kepada bot yang telah menunggu lebih lama (jika ada ikatan, bot yang telah menunggu waktu maksimum semua diizinkan untuk menuai dan mendapatkan poin di menuai)
• Bot Anda harus rata-rata tidak lebih dari 100 ms melintasi 5 tick.
• Jika Anda ingin mengimpor perpustakaan, tanyakan! Saya akan mencoba menambahkan perpustakaan yang dapat saya jalankan di Python versi desktop saya (matematika sudah diimpor: silakan menggunakannya)
• Semua celah standar untuk KoTHs, seperti duplikat bot, bot 1-up, dll, juga dilarang.
• Setiap bot yang menggunakan segala jenis keacakan harus menggunakan getRandomfungsi yang saya berikan.

Anda dapat menemukan pengontrol di tautan TIO di bawah ini. Untuk menggunakannya, tambahkan nama fungsi Anda BotListsebagai string, lalu tambahkan fungsi ke kode. Ubah multiplieruntuk mengubah apa menuai dikalikan dengan setiap centang, modifikasi winning_scoreuntuk mengubah skor apa yang diperlukan untuk mengakhiri permainan, dan modifikasiwaittime untuk mengubah jumlah tick untuk menunggu di antara menuai.

Untuk kenyamanan Anda, berikut adalah beberapa bot sampel (dan agak konyol). Mengirimkan bot yang serupa dengan ini tidak akan diizinkan. Namun, mereka menunjukkan cara kerja pengontrol.

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

Bagi yang berminat, inilah Controller dengan 15 kiriman yang disertakan di dalamnya: Cobalah Online

HASIL AKHIR

WOO MEREKA AKHIRNYA AKAN DI SINI! Periksa TIO Link di atas untuk melihat kode apa yang saya gunakan untuk menghasilkan peringkat akhir. Hasilnya tidak terlalu menarik. Lebih dari 1000 berjalan saya lakukan dengan biji acak yang berbeda, hasilnya adalah

1000 wins - Jack
0 wins - everyone else

Selamat kepada pemenang Bounty, Jack !! (alias @Renzeee)

Bingung Twitchy Mess

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 ini melakukan pengecekan seperti biasa (Bisakah saya menuai, bisakah saya menang?) Dan kemudian mencari nilai target sebelum menuai. Namun, itu bimbang, jadi setelah mencapai target, ia bertanya-tanya berapa lama ia bisa menunggu dan tidak segera menuai. Selain itu, itu gugup, sehingga mungkin tidak sengaja "menekan tombol" dan menuai di depan target.

Fakta menyenangkan: Ini pada dasarnya bagaimana saya bermain mesin penuai sebagai manusia.

Penembak jitu

Bot didorong oleh dendam. Melacak cooldown dan skor lawan. Berusaha agar orang lain tidak menang. Cukup banyak yang tidak pernah benar-benar menang, tetapi membuat permainan frustasi untuk bermain untuk orang lain.

EDIT:

• Jika menuai akan menyebabkannya menang, menuai.

• Jika tidak ada yang> = 70% dari skor kemenangan:

  • Jika semua orang ada di cooldown mereka, tunggu sampai saat terakhir yang memungkinkan untuk menuai.
  • Jika ada orang lain yang menang dengan menuai nilai saat ini, dan mereka aktif sekarang atau akan aktif giliran berikutnya, menuai.
  • Jika setidaknya setengah dari pengguna lain ada di cooldown mereka, cobalah untuk menuai. Ini membuatnya sulit untuk menargetkan lawan tertentu, dan begitu juga dihapus.
  • Kalau tidak, tuai 25% dari waktu (pada dasarnya untuk menjamin bahwa bot ini memang menuai SOMETIM, kalau-kalau terjadi sesuatu yang aneh, seperti semua orang menunggu beberapa putaran).

• Jika seseorang IS> = 70% dari skor kemenangan:

  • Jika Sniper dapat memenangkan tiebreak, dan ronde berikutnya akan berada di atas nilai Menuai rata-rata untuk lawan dengan skor tertinggi, menuai
  • Jika lawan dengan skor tertinggi akan meninggalkan cooldown mereka di giliran berikutnya, menuai.

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

Bosan

Hanya untuk bersenang-senang, bot ini dibawa oleh seorang teman dan sebenarnya tidak ingin berada di sini. Mereka menggulirkan d16 hingga mendapatkan angka di 1-9, kemudian mereka berusaha menuai kapan saja angka berisi digit yang dipilih. (Pergi untuk mencari d10 akan mengganggu permainan, yang kasar, dan 0 terlalu mudah!)

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

Mendongkrak

Ini adalah bot sederhana dengan 4 aturan:

• Jangan menuai ketika itu tidak melakukan apa-apa
• Selalu menuai ketika menuai membuat kita menang
• Juga menuai ketika belum ada menuai untuk 3 ticks
• Kalau tidak, jangan lakukan apa-apa

Saya telah mengoptimalkan 3 ticks dibandingkan bot yang ada saat ini (Sniper, grim_reaper, Every50, mess, BetterRandom, Averager, dan lainnya).

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

Saya telah mencoba untuk tetap dengan solusi lama saya (5 ticks) tetapi juga menuai jika Anda belum menuai lebih lama dari X ticks, dan kemudian menuai setelah lebih sedikit ticks berlalu selama non-reaping (yaitu 5, jika menunggu lebih lama dari diri sendiri .waittime + 5, juga menuai jika tidak menuai 4 ticks). Tapi ini tidak membaik hanya selalu menuai setelah 4 ticks bukannya 5.

Setiap 50

Bot ini akan menuai setiap kali Reapjumlahnya di atas 50.

Mengapa 50?

Jika saya membuat asumsi akan ada 25 bot dalam permainan, itu berarti multiplier = 1.6-(1.2/(1+sqrt(25))) = 1.4dan waittime = floor(1.5*25) = 37. Sejak Reapdimulai 1, itu akan naik seperti ini:

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.

Seperti yang Anda lihat, itu mencapai di atas 50 setelah 13 kutu. Karena Reapakan reset ke 1 setiap kali bot menuai, dan waittimeuntuk bot yang menuai adalah 37, kemungkinan bot menuai lebih cepat daripada nanti cukup tinggi, terutama dengan bot mirip dengan contoh GreedyBot, yang akan menuai secepat mereka waittimeyaitu tersedia lagi. Awalnya saya ingin melakukan 200 yang merupakan kutu ke-17, agak di tengah-tengah dari 37 kutu waktu tunggu, tetapi dengan asumsi ada 25 bot dalam bermain ada kemungkinan cukup tinggi orang lain menyambar Reapsebelum saya. Jadi saya menurunkannya menjadi 50. Itu masih angka bulat yang bagus, tetapi terutama karena ini adalah tick ke-13 (dengan 25 bot), dan 13 dan menuai juga cocok dengan genre 'jahat' yang sama.

Kode:

Kode ini sepele menggelikan ..

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

Catatan:

Bot ini sangat buruk dengan jumlah bot yang rendah. Untuk saat ini saya akan meninggalkannya, dan saya mungkin membuat bot yang lebih baik sebenarnya menghitung waktu terbaik untuk itu Reap. Dengan jumlah bot yang sangat rendah dalam permainan waittime, tentu saja ini jauh lebih rendah, jadi bahkan GreedyBotmungkin menang dengan mudah dari bot ini jika botnya waittimecukup rendah.

Semoga lebih banyak orang akan menambahkan lebih banyak bot. ; p

Averager

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 ini mencoba menuai kapan saja nilai Menuai saat ini di atas nilai Menuai rata-rata.

Malaikat maut

Bot ini menyimpan rata-rata berjalan dari semua nilai menuai sebelumnya serta waktu setiap bot telah menunggu. Menuai ketika telah menunggu lebih dari 3/4 dari bot lain dan menuai setidaknya 3/4 ukuran rata-rata menuai sejauh ini. Tujuannya adalah untuk mengambil banyak menuai risiko yang cukup masuk akal dan rendah.

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

Sunting: Memperbaiki beberapa kesalahan sintaksis yang memalukan.

Cobalah secara Online

BetterRandom

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

Bot didasarkan pada asumsi bahwa peluang untuk menuai harus proporsional dengan ukuran menuai karena suatu titik adalah sebuah titik, tidak peduli kapan itu didapat. Selalu ada peluang yang sangat kecil untuk menuai, ini membuat perilaku dapat dieksploitasi. Pertama saya pikir itu akan langsung proporsional dan diasumsikan konstan proporsional berada di sekitar1/mult^waittime (menuai maksimum dengan asumsi setidaknya satu bot bermain serakah) setelah menjalankan beberapa simulasi saya menemukan bahwa ini memang konstanta optimal. Tetapi bot itu masih mengungguli oleh Random jadi saya menyimpulkan hubungan itu tidak secara langsung proporsional dan menambahkan konstanta untuk menghitung apa hubungan itu. Setelah beberapa simulasi saya menemukan itu terhadap set tes bot saya-1.5 adalah optimal. Ini sebenarnya sesuai dengan hubungan proporsional terbalik antara peluang menuai danreap*sqrt(reap)yang mengejutkan. Jadi saya menduga ini sangat tergantung pada bot tertentu sehingga versi bot ini yang menghitung k saat bermain akan lebih baik. (Tapi saya tidak tahu apakah Anda diizinkan untuk menggunakan data dari putaran sebelumnya).

EDIT: Saya membuat program untuk menemukan jenis proporsionalitas secara otomatis. Pada set tes ["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"]saya menemukan nilai baru.

Target

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

Peluang saya untuk menang dengan kekacauan hampir tidak ada sekarang, jadi waktu untuk mengacaukan semua bot lainnya dalam banyak cara! :)

Bot ini fungsinya mirip dengan sniper. Setiap kali seseorang menuai, ia mengambil target acak dari siapa pun yang menuai. Kemudian, ia hanya menunggu sampai target itu hampir dapat menuai lagi dan menembaknya. Namun, itu tidak mengubah fokus - setelah Anda dipilih dan dikunci, Anda tidak dapat melarikan diri :)

Semua orang

Saya kira sudah waktunya untuk bot kedua saya tepat sebelum batas waktu.

Bot ini akan:

• Lewati ketika masih dalam waktu menunggu untuk menuai terakhir
• Menuai kapan itu bisa menang
• Menuai ketika tidak ada yang menuai setidaknya nputaran, di mana ndihitung dengann = 3 + ceil(self.waittime / self.lenBots)

Kode:

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

Saya tidak terlalu sering memprogram dalam Python, jadi jika Anda melihat kesalahan, beri tahu saya.

Sedang berjalan: Proyek saya untuk memperluas T4T ke setiap KOTH terbuka.

Gayung bersambut

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

Tit untuk 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

Hanya untuk membuat Anda tetap waspada.

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

Joe rata-rata

Saya terinspirasi oleh Averager dan membuat bot yang menghitung rata-rata berapa banyak putaran yang diperlukan sebelum seseorang menuai dan mencoba memetik satu putaran sebelum itu.

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

HardCode

Ya itu.

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

Alih-alih rata-rata pada masa lalu menuai, gunakan rata-rata yang sudah dihitung sebelumnya pada menjalankan khas. Lagipula itu tidak akan membaik seiring waktu.