NOT : Bu yarışmanın galibi Jack !!!. Başka başvuru kabul edilmeyecek.

İşte bu tepenin kralı mücadelesi için sohbet odası . Bu benim ilkim, bu yüzden önerilere açığım!

Reaper sabır ve açgözlülük içeren Problem Çözme Sanatı tarafından geliştirilen bir oyun konseptidir. Oyunu KOTH tarzı bir yarışmaya uyacak şekilde değiştirdikten sonra (Önerileriniz ve iyileştirmeleriniz için @NathanMerrill ve @dzaima'ya teşekkürler), işte zorluk.

Oyun şu şekilde çalışır: Reap olarak bilinen ve her tik üzerinde belirli bir sabitle çarpılan bir değere sahibiz. Her işaretlemeden sonra, her bot "reaping" seçeneğine sahiptir, bu da Reap'in geçerli değerini bir kişinin skoruna eklemek ve Reap'i 1'e düşürmek anlamına gelir.

Ancak, bir botun "reaps" arasında beklemesi gereken sabit sayıda keneler ve oyunu kazanmak için gereken sabit sayıda puan vardır.

Yeterince basit? Girdileriniz şunlardır:

I / O

Python 3'te 3 giriş alan bir fonksiyon yazmalısınız. Birincisi self, sınıf nesnelerine başvurmak için kullanılır (daha sonra gösterilecektir). İkincisi, Reap"biçmek" olsaydınız kazanacağınız Reap'in şu anki değeri. Üçüncüsü prevReap, bir önceki kene sırasında toplanan botların bir listesidir.

İşlevinizde erişebileceğiniz diğer nesneler:

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.

Bunun dışında, bu nesnelerin içeriklerini düzenlememeniz GEREKİRself.obj .

1Biçmek için çıktı almalısınız ve biçmemek için başka bir şey (ya da hiçbir şey). Yeterince keneyi beklemediğinizde biçerseniz, biçmeyi seçtiğinizi görmezden geleceğim.

kurallar

Ben kullanacak parametrelerdir winning_score=10000, multiplier=1.6-(1.2/(1+sqrt(x))), waittime = floor(1.5*x)nerede xKoth içinde botlara sayısıdır.

• Bir oyuncu (veya çoklu) kazanan puana ulaştığında oyun sona erer.
• Birden fazla bot bir kerede biçilmesini istediğinde, daha uzun süre bekleyen botlara öncelik verilir (bağlar durumunda, maksimum süreyi bekleyen botların toplanmasına ve Reap'ta puan kazanmasına izin verilir)
• Botunuz 5 kenede ortalama 100 ms'den fazla sürmemelidir.
• Kütüphaneleri içe aktarmak istiyorsanız, sorun! Python'un masaüstü sürümümde çalıştırabileceğim kütüphaneleri eklemeye çalışacağım (matematik zaten içe aktarıldı: kullanmaktan çekinmeyin)
• Yinelenen botlar, 1-up botlar vb.Gibi KoTH'ler için tüm standart boşluklar benzer şekilde yasaklanmıştır.
• Herhangi bir tür rastgelelik kullanan botlar sağladığım getRandomfonksiyonu kullanmalıdır .

Denetleyiciyi aşağıdaki TIO bağlantısında bulabilirsiniz. Bunu kullanmak için, işlevinizin adını BotListdize olarak ekleyin ve sonra işlevi koda ekleyin. Reap'in multiplierher bir kene ile çarpıldığını değiştirmek winning_scoreiçin değiştirin, oyunu bitirmek için gereken puanı değiştirmek waittimeiçin değiştirin ve reaplar arasında beklenecek kenelerin sayısını değiştirmek için değiştirin.

Size kolaylık sağlamak için, bazı örnek (ve daha aptalca) botlar. Bunlara benzer botların gönderilmesine izin verilmeyecektir. Ancak, denetleyicinin nasıl çalıştığını gösterirler.

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

İlgilenenler için, içinde 15 gönderim bulunan Denetleyici: Çevrimiçi Deneyin

NİHAİ SONUÇLAR

WOO ONLAR NEDEN BURADA! Son sıralamaları oluşturmak için hangi kodu kullandığımı görmek için yukarıdaki TIO Bağlantısını kontrol edin. Sonuçlar çok ilginç değil. Farklı rastgele tohumlarla yaptığım 1000 koşu boyunca, sonuçlar

1000 wins - Jack
0 wins - everyone else

Ödül kazanan Jack'i tebrik ediyoruz !! (aka @Renzeee)

Kararsız Twitchy Karışıklık

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

Bu bot ilk önce olağan kontrolleri yapar (Toplayabilir miyim, kazanabilir miyim?) Ve sonra bir hedef değeri arar. Bununla birlikte, kararsızdır, bu nedenle hedefe ulaştıktan sonra, daha ne kadar bekleyebileceğini merak eder ve hemen tepki vermez. Ayrıca, seğirme, bu yüzden yanlışlıkla "düğmeye basın" ve hedeften önce biçmek olabilir.

Eğlenceli gerçek: Temelde insan olarak orakçı çalıyorum.

Keskin nisanci

Rağmen yakıt körükledi. Rakibin bekleme sürelerini ve skorlarını takip eder. Başkalarının kazanmasını engelleme girişimleri. Hemen hemen hiç kazanmaz, ancak oyunu başkaları için oynamak sinir bozucu hale getirir.

DÜZENLE:

• Hasat kazanmaya neden olursa, biçin.

• Hiç kimse kazanan puanın> =% 70'i değilse:

  • Diğer herkes bekleme süresindeyse, biçmek için mümkün olan en son ana kadar bekleyin.
  • Başka biri geçerli değeri elde ederek kazanırsa ve şimdi etkinse veya bir sonraki turda etkin olacaksa, biçin.
  • Diğer kullanıcıların en az yarısı bekleme süresindeyse, biçmeyi deneyin. Bu, belirli rakipleri hedeflemeyi zorlaştırır ve böylece kaldırıldı.
  • Aksi takdirde, zamanın% 25'ini toplayın (esasen, bu botun bazı şeyleri beklemesi durumunda, herkesin birkaç tur beklediği gibi, bazı botları elde ettiğini garanti etmek için).

• Birisi IS> = kazanan puanın% 70'i ise:

  • Sniper bir tiebreaker kazanabiliyorsa ve bir sonraki tur, en yüksek puan alan rakibin ortalama Reap değerinin üzerinde olursa, biçin
  • En yüksek puan alan rakip bekleme sürelerini bir sonraki dönüşte bırakırsa, biçin.

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

Canı sıkkın

Sadece eğlence için, bu bot bir arkadaş tarafından getirildi ve aslında burada olmak istemiyor. 1-9 arasında bir sayı elde edene kadar bir d16 yuvarlarlar, daha sonra bir sayı seçilen rakamı içerdiğinde biçmeye çalışırlar. (Bir d10 arayacaksanız oyunu bozarsınız, bu kaba ve 0 çok kolay!)

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

kriko

Bu 4 kurallı basit bir bot:

• Hiçbir şey yapmadığında hasat etme
• Hasat yaparken her zaman biçin kazanmamızı sağlar
• Ayrıca, 3 keneyle hasat edilmediğinde de biçin
• Aksi takdirde hiçbir şey yapmayın

Mevcut mevcut botlara karşı 3 keneyi optimize ettim (Sniper, grim_reaper, Every50, karışıklık, BetterRandom, Averager, biraz daha).

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

Eski çözümümle kalmaya çalıştım (5 keneler), ancak X kenelerinden daha uzun süre biçemediyseniz de biçin ve daha sonra kenetlenme sırasında daha az keneler geçtikten sonra biçin (yani 5, kendinden daha uzun süre beklediyseniz .waittime + 5, ayrıca 4 keneler için biçilmemişse biçer). Ancak bu, 5 yerine 4 keneden sonra her zaman hasat yapmadı.

Her 50

Bu botlar, Reapmiktar 50'nin üzerinde olduğunda biçer.

Neden 50?

Ben varsayım oyunda 25 botlar olacak yaparsanız, bu demektir multiplier = 1.6-(1.2/(1+sqrt(25))) = 1.4ve waittime = floor(1.5*25) = 37. Başlangıcından bu yana, Reapşu 1şekilde yükselecektir:

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.

Gördüğünüz gibi, 13 keneden sonra 50'nin üzerine çıkıyor. Yana Reapbir bot reaps 1'e her defasında sıfırlar ve waittimereaps 37, bir bot reaps er daha sonra olabilirlik olduğunu bir bot için özellikle örneğe benzer botlar ile oldukça yüksektir GreedyBotonların en kısa sürede hasat edecektir, waittimeIS tekrar kullanılabilir. İlk başta, 37 bekleme süresi kenesinin ortasında, 17. kene olan 200 yapmak istedim, ancak varsayımla, oyunda 25 bot var, bir başkasının Reapbenden önce kapışması oldukça yüksek bir şans var. Bu yüzden 50'ye indirdim. Hala güzel yuvarlak bir sayı, ama özellikle 13. kene (25 bot ile) ve 13 ve 'biçmek' de aynı 'kötü' türe biraz uyuyor.

Kod:

Kod gülünç önemsizdir.

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

Notlar:

Bu bot, oyundaki düşük bot sayısı ile oldukça kötü. Şimdilik bırakacağım ve aslında en iyi zamanı hesaplamak için daha iyi bir bot yapabilirim Reap. Oyunda son derece düşük sayıda bot waittimeile elbette çok daha düşüktür, bu yüzden yeterince düşükse GreedyBotbile bu bottan kolayca kazanabilir waittime.

Umarım daha fazla insan çok daha fazla bot ekler. s

Ortalama Alma

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

Bu bot, geçerli Reap değeri ortalama Reaped değerinin üzerinde olduğunda biçer.

Azrail

Bu bot, önceki botların değerlerinin ve her botun beklediği sürenin çalışma ortalamasını tutar. Diğer botların 3 / 4'ünden daha uzun süre beklediğinde ve reap, şimdiye kadar görülen ortalama reap boyutunun en az 3 / 4'ü kadar olduğunda ortaya çıkar. Amaç, çok sayıda makul boyutta, düşük riskli reaps elde etmektir.

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

Düzenleme: Bazı utanç verici sözdizimi hataları düzeltildi.

Çevrimiçi Deneyin

BetterRandom

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

Bot, hasat etme şansının hasat boyutuyla orantılı olması gerektiği varsayımına dayanır, çünkü ne zaman olursa olsun bir nokta bir noktadır. Her zaman hasat için çok küçük bir şans vardır, bu davranışı sömürülebilir tutar. İlk olarak bunun doğrudan orantılı olacağını düşündüm ve 1/mult^waittimebazı simülasyonları çalıştırdıktan sonra oransallık sabitinin (en az bir botun açgözlü oynadığı varsayılarak azami miktar) olduğunu varsaydım, bunun gerçekten optimal sabit olduğunu gördüm. Ama bot hala Random tarafından daha iyi performans gösterdi, bu yüzden ilişkinin doğrudan orantılı olmadığı sonucuna vardım ve ilişkinin ne olduğunu hesaplamak için bir sabit ekledim. Bazı simülasyonlardan sonra test botlarıma karşı -1.5optimal olduğunu gördüm . Bu aslında hasat şansı ile gerçek olmayan şans arasında ters orantılı bir ilişkiye karşılık gelir.reap*sqrt(reap)ki bu şaşırtıcı. Bu yüzden bunun belirli botlara bağlı olduğundan şüpheleniyorum, bu yüzden bu botun oynarken k değerini hesaplayan bir versiyonu daha iyi olurdu. (Ama önceki turlardan veri kullanmanıza izin verilip verilmediğini bilmiyorum).

EDIT: Otomatik olarak oransallık türünü bulmak için program yaptım. Test setinde ["myBot("+str(k)+")","Randombot","Greedybot","Every50","Jack","grim_reaper","Averager","mess"]yeni değeri buldum.

Hedef

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

Dağınıklıkla kazanma şansım neredeyse yok, bu yüzden diğer tüm botları mümkün olduğunca çok şekilde karıştırmanın zamanı geldi! :)

Bu bot keskin nişancıya benzer. Birisi ne zaman tepki verirse, onu biçen kişiden rastgele bir hedef seçer. Daha sonra, bu hedef neredeyse tekrar toplanıp onu yakalayana kadar bekler. Ancak, odağı değiştirmez - seçildikten ve kilitlendikten sonra kaçamazsınız :)

EveryN

Sanırım son botumdan hemen önce ikinci botumun zamanı geldi.

Bu bot:

• Hala son Reap için bekleme süresinde atla
• Ne zaman kazanabilir?
• Kimse en azından için hasat zaman biçmek nmermi, burada nhesaplanırn = 3 + ceil(self.waittime / self.lenBots)

Kod:

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'da çok sık program yapmıyorum, bu yüzden herhangi bir hata görürseniz bana bildirin.

Devam ediyor: Projem T4T'yi her açık KOTH'a genişletme.

Tat için baştankara

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

N Tats için baştankara

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

Sadece seni diken üstünde tutmak için.

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

Ortalama Joe

Averager'dan ilham aldım ve birisinin tepki vermeden ve ondan önce bir tur hasat etmeye çalışmadan önce kaç tur alacağını hesaplayan bir bot oluşturdum.

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

Evet öyle.

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

Geçmiş reaplarda ortalama almak yerine, tipik bir koşuda önceden hesaplanmış bir ortalama kullanın. Zaten zamanla daha iyi olmayacak.