Testfahrer • Herausforderung Diskussion • Submit Adventurer

( Bildquelle )

Mehrere rivalisierende Abenteurer durchsuchen die Ruinen nach Schätzen, können aber nur so viel auf einmal tragen und haben ihre Grenzen der Ausdauer. Sie möchten den wertvollsten Schatz finden und hinausgehen, bevor sie zu müde werden, um fortzufahren. Sie versuchen, durch ihre Plünderungen so reich wie möglich zu werden.

Gameplay

Jeder Abenteurer beginnt im ersten Raum des Dungeons mit 1000 Ausdauerpunkten und 50 kg Platz im Rucksack.

Das Spiel funktioniert rundenbasiert, wobei alle Spieler gleichzeitig ihre Züge abwickeln. In jeder Runde kannst du eine der folgenden Aktionen ausführen:

• Gehe in den nächsten Raum.
• Zum vorherigen Raum gehen.
• Bieten Sie Ausdauer, um einen Schatz zu nehmen.
• Lass einen Schatz fallen.

Der Wechsel zwischen den Räumen erfordert 10 Ausdauer plus 1 Ausdauer pro 5 kg, die sich gerade in Ihrem Rucksack befinden. Zum Beispiel benötigt ein Abenteurer, der 3 kg Schatz trägt, 11 Ausdauer, und ein Abenteurer, der 47 kg trägt, benötigt 20 Ausdauer, um sich zu bewegen.

Das Fallenlassen eines Schatzes erfordert 1 Ausdauer, unabhängig davon, welcher Schatz gefallen ist.

Beim Verlassen der Ruinen werden vom Spieler keine Züge mehr ausgeführt.

Wenn ein Spieler keine dieser Aktionen ausführen kann (aufgrund mangelnder Ausdauer oder fehlender Schätze), stirbt sein Abenteurer vor Erschöpfung und verschüttet seinen gehaltenen Schatz in den aktuell besetzten Raum. Wenn ein Spieler versucht, eine ungültige Aktion auszuführen, wird sein Abenteurer stattdessen durch eine Falle getötet, was zur gleichen Verschwendung von Schätzen führt.

Bieten

Das Mindestgebot für einen Schatz beträgt 1 Ausdauer pro 1 kg, das der Schatz wiegt. Sie können auch zusätzliche Ausdauerpunkte bieten, um den Schatz mit größerer Wahrscheinlichkeit zu erhalten. Die gebotene Ausdauer wird unabhängig vom Ergebnis verbraucht.

Falls mehrere Spieler geboten haben, denselben Schatz zu nehmen, erhält der Spieler, der das höchste Gebot abgegeben hat, den Schatz. Wenn mehr als ein Spieler das höchste Gebot abgegeben hat, erhält keiner von ihnen den Schatz.

Gewinnbedingung

Der Spieler mit dem höchsten Gesamtwert an Schätzen ist der Gewinner. Im unwahrscheinlichen Fall eines Unentschieden gehen die Unentschieden zum kleinsten Gesamtgewicht, dann zur kleinsten Anzahl von Schätzen, dann zum Wert des wertvollsten Schatzes, zum zweitwertvollsten, zum dritten ... bis das Unentschieden gebrochen ist. Für den nahezu unmöglichen Fall, dass es an dieser Stelle noch ein Unentschieden gibt, sagt der Testfahrer "Screw it" und der Sieger wird dabei willkürlich ermittelt.

Im Rahmen des Turniers erhalten die Spieler den ersten Platz mit 10 Punkten, den zweiten Platz mit 9 Punkten, den dritten Platz mit 8 Punkten usw., wobei tote Spieler und Abenteurer ohne Schätze 0 Punkte erzielen.

Über die Ruinen

• Jeder Raum enthält anfangs zwischen $\lfloor{r \over 3}\rfloor + 3$und$\lfloor{r \over 2}\rfloor + 5$Schätze. (Wobei$r$die Zimmernummer ist)
• Es gibt beliebig viele Räume, die nur durch die Ausdauer und Erkundungsbereitschaft der Abenteurer begrenzt sind.
• Jeder Schatz hat einen Geldwert (in ganzen $) und ein Gewicht (in ganzen kg).
  • Schätze sind in der Regel wertvoller und zahlreicher, wenn Sie tiefer in die Ruinen vordringen.
• Die spezifischen Formeln zum Erzeugen von Schätzen lauten wie folgt: (Verwenden der $xdy$ -Notation für Würfelwürfe)
  • Das Gewicht wird zuerst mit der Formel $2d6 - 2$ berechnet. D 6 - 2 (mindestens 1)
  • Der Schatzwert wird dann über $1d[10 * w] + 2d[5 * r+ 10]$ (wobei$r$ die Raumnummer und$w$ das Gewicht ist).

Für Spieler sichtbare Informationen

In jedem Zug erhalten die Spieler die folgenden Informationen:

• Die Nummer des Raums, in dem sie sich gerade befinden. Dies ist 1-indiziert, daher befindet sich der Ausgang konzeptionell bei "Raum 0".
• Eine Liste der aktuell im Raum befindlichen Schätze
• Eine Liste der anderen Spieler, die sich ebenfalls gerade im Raum befinden.
• Ihr aktueller Schatzbestand
• Ihre aktuelle Ausdauer

Codierung

Den Testfahrer finden Sie hier .

Sie sollten eine Unterklasse davon implementieren Adventurer Klasse :

class Adventurer:
    def __init__(self, name, random):
        self.name = name
        self.random = random

    def get_action(self, state):
        raise NotImplementedError()

    def enter_ruins(self):
        pass

Sie müssen nur die get_actionMethode überschreiben . enter_ruinswird ausgeführt, bevor ein Spiel beginnt, und ist Ihre Chance, alles vorzubereiten, was Sie für das Spiel bereithalten möchten. Sie müssen nicht überschreiben __init__, und Sie sollten es wirklich nicht tun . Wenn Sie __init__abstürzen, werden Sie disqualifiziert.

get_action erhält ein einziges Argument, das a ist namedtuple mit den folgenden Feldern (in dieser Reihenfolge, wenn Sie die Destrukturierung bevorzugen):

• room: Die Nummer des Raumes, in dem Sie sich gerade befinden
• treasures: die Liste der Schätze im Raum
• players: die Liste der anderen Spieler im Raum. Auf diese Weise erhältst du nur den Spielernamen, sodass du nicht weißt, welcher Bot sie kontrolliert oder welches Inventar / welche Ausdauer sie haben.
• inventory: die Liste der Schätze in Ihrem Rucksack
• stamina: Ihre aktuelle Ausdauer

Dieses Objekt bietet zusätzlich zwei Utility-Eigenschaften:

• carry_weight: das Gesamtgewicht aller Schätze, die Sie tragen
• total_value: der Gesamtwert aller Schätze, die Sie tragen

Die treasuresund inventoryListen enthalten namedtuples mit diesen Attributen:

• name: der Name des Schatzes (für kosmetische Zwecke)
• value: der Geldwert des Schatzes in $.
• weight: das Gewicht des Schatzes in kg

get_action sollte einen der folgenden Werte / Muster zurückgeben:

• 'next'oder 'previous', um zum nächsten / vorherigen Raum zu wechseln
• 'take', <treasure index>, <bid>(Ja, als Tupel, obwohl jede Sequenz auch technisch funktioniert), um auf den Schatz an dem angegebenen Index in der Schatzliste des Raums zu bieten. Beide Argumente sollten Ganzzahlen sein. Schwimmer werden abgerundet.
• 'drop', <inventory index>den getragenen Schatz fallen zu lassen, der bei dem gegebenen Index gefunden wurde. Der Index sollte (natürlich) eine ganze Zahl sein.

Andere Einschränkungen

• Sie dürfen nur die zufällige Instanz verwenden, die Ihnen während der Initialisierung für Pseudozufälligkeit zur Verfügung gestellt wurde.
  • Alles andere, was einen verhaltensbedingten Nichtdeterminismus hervorrufen könnte, ist nicht erlaubt. Die Absicht hierbei ist, dass Bots sich identisch verhalten, wenn sie denselben Startwert erhalten, um beim Testen neuer Bots (und potenziellen Bugs im Testtreiber) zu helfen. Nur kosmische Strahlung sollte Abweichungen / Nichtdeterminismus verursachen.
  • Denken Sie daran, dass Hash-Codes in Python 3 zufällig angeordnet sind, sodass die Verwendung hashfür Entscheidungen nicht zulässig ist. dicts sind in Ordnung, auch wenn die Iterationsreihenfolge für Entscheidungen verwendet wird, da die Reihenfolge seit Python 3.6 garantiert konsistent ist.
• Sie dürfen den ctypesTesttreiber nicht mit Hacks oder inspectStack-Voodoo (oder einer anderen Methode) umgehen . Es gibt einige beeindruckend beängstigende Dinge, die Sie mit diesen Modulen tun können. Bitte nicht
  • Jeder Bot ist durch defensive Kopien und die natürliche Unveränderlichkeit von einigermaßen gut in Sandkästen eingeschlossen namedtuple s , aber es gibt einige unverbesserliche Schlupflöcher / Exploits.
  • Andere Funktionen von inspectund ctypeskönnen verwendet werden, sofern keine davon zur Umgehung der Steuerungsfunktionen verwendet wird.
  • Es ist nicht zulässig, Instanzen der anderen Bots in Ihrem aktuellen Spiel zu erfassen.
• Bots sollten alleine agieren und dürfen sich in keiner Weise für irgendeinen Zweck mit anderen Bots koordinieren. Dies beinhaltet das Erstellen von zwei Bots mit unterschiedlichen Zielen, sodass sich einer für den Erfolg des anderen opfert. Sobald es mehr als 10 Konkurrenten gibt, kann nicht garantiert werden, dass die beiden Bots im selben Spiel sind, und die Namen der Abenteurer geben keinen Hinweis auf die Bot-Klasse. Daher sind diese Arten von Strategien ohnehin begrenzt.
• Derzeit gibt es keine feste Beschränkung der Ausführungszeit. Ich behalte mir jedoch das Recht vor, die Ausführungszeit in Zukunft zu beschränken, wenn Turniere zu lange dauern. Seien Sie vernünftig und versuchen Sie, die Verarbeitung unter 100 ms zu halten , da ich nicht damit , sie unter diesen Schwellenwert einschränken zu müssen. (Turniere dauern ungefähr 2 Stunden, wenn alle Bots ungefähr 100 ms pro Runde benötigen.)
• Ihre Bot-Klasse muss unter allen Einsendungen eindeutig benannt sein.
• Sie können sich an nichts zwischen Spielen erinnern. (Sie können sich jedoch an Dinge zwischen den Runden erinnern )
  • Bearbeiten Sie keine sys.modules. Alle externen Instanzvariablen sollten als Konstante behandelt werden.
• Sie dürfen den Code eines Bots einschließlich Ihres eigenen Codes nicht programmgesteuert ändern.
  • Dies beinhaltet das Löschen und Wiederherstellen Ihres Codes. Dies soll das Debuggen und die Turniere rationalisieren.
• Jeder Code, der zum Absturz des Controllers führt, wird sofort disqualifiziert. Während die meisten Ausnahmen abgefangen werden, können einige durchrutschen und Fehler können nicht abgefangen werden. (Ja, Sie können in Python dank segfault ctypes)

Einreichungen

Geben Sie oben in der Antwort den Namen Ihres Bots mit einem an, um die Antwortverwaltung zu vereinfachen #Header1 und stellen Sie sicher, dass Ihre Antwort mindestens einen Codeblock enthält (nur der erste in Ihrer Antwort wird verwendet). Sie müssen keine Importe oder Dokumentzeichenfolgen einfügen, da diese vom Scraper automatisch hinzugefügt werden.

Ich werde eher geneigt sein, Antworten mit detaillierten und verständlichen Erklärungen abzustimmen. Andere werden sich wahrscheinlich genauso verhalten.

Grob gesagt sollte Ihre Antwort so formatiert sein:

# Name of Bot
Optional blurb

    #imports go here

    class BotName(Adventurer):
        #implementation

Explanation of bot algorithm, credits, etc...

(gerendert als)

Name des Bots

Optionaler Klappentext

#imports go here

class BotName(Adventurer):
    #implementation

Erklärung von Bot-Algorithmen, Credits, etc ...

Lokales Ausführen des Testtreibers

Sie benötigen Python 3.7+ und ich empfehle, dass Sie auch tabulateüber Pip installieren . Das Scrappen dieser Seite für Einreichungen erfordert zusätzlich lxmlund requests. Sie sollten auch ein Terminal mit Unterstützung für ANSI-Farbverluste verwenden, um optimale Ergebnisse zu erzielen. Informationen zum Einrichten in Windows 10 finden Sie hier .

Fügen Sie Ihren Bot zu einer Datei in einem Unterverzeichnis in demselben Verzeichnis wie ruins.py( ruins_botsstandardmäßig) hinzu und stellen Sie sicher, dass Sie ihn from __main__ import Adventureroben im Modul hinzufügen . Dies wird zu den Modulen hinzugefügt, wenn der Scraper Ihre Einreichung herunterlädt, und obwohl es definitiv hacky ist, ist dies die einfachste Möglichkeit, um sicherzustellen, dass Ihr Bot richtig Zugriff hat Adventurer.

Alle Bots in diesem Verzeichnis werden zur Laufzeit dynamisch geladen, sodass keine weiteren Änderungen erforderlich sind.

Turnier

Der endgültige Sieger wird in einer Reihe von Spielen mit bis zu 10 Bots in jedem Spiel ermittelt. Bei mehr als 10 Einsendungen werden die 10 besten Bots ermittelt, indem sie systematisch in 10er-Gruppen aufgeteilt werden, bis jeder Bot (genau) 20 Spiele gespielt hat. Die Top 10 Bots werden aus dieser Gruppe mit zurückgesetzten Punktzahlen ausgewählt und spielen solange, bis der Erstplatzierte einen Vorsprung von 50 Punkten vor dem Zweitplatzierten erreicht hat oder bis 500 Spiele gespielt wurden.

Bis mindestens 10 Einsendungen vorliegen, werden leere Slots mit "Säufer" gefüllt, die nach dem Zufallsprinzip durch die Ruinen wandern und zufällige Schätze einsammeln (und gelegentlich fallen lassen), bis ihnen die Ausdauer ausgeht und sie geradewegs zum Ausgang müssen.

Turniere werden wöchentlich wiederholt, wenn neue Einreichungen vorliegen. Dies ist eine offene KOTH-Challenge ohne festgelegtes Enddatum.

Bestenliste

Vom Lauf am 4. Mai 2019 um 16:25 Uhr MEZ: (04.05.2019 16:25 - 06:00 Uhr)

Seed: K48XMESC
 Bot Class    |   Score |   Mean Score
--------------+---------+--------------
 BountyHunter |     898 |        7.301
 Scoundrel    |     847 |        6.886
 Accountant   |     773 |        6.285
 Ponderer     |     730 |        5.935
 Artyventurer |     707 |        5.748
 PlanAhead    |     698 |        5.675
 Sprinter     |     683 |        5.553
 Accomodator  |     661 |        5.374
 Memorizer    |     459 |        3.732
 Backwards    |     296 |        2.407

Update - 15. April: Einige Regel-Updates / Klarstellungen

Update - 17. April: Verbot einiger bemerkenswerter Fälle schändlicher Handlungen wie das Ändern des Codes anderer Bots.

Update - 4. Mai: Sleafar erhält Kopfgeld, weil er Rückwärts absolut zerstört hat. Herzliche Glückwünsche!

Buchhalter

import math

class Accountant (Adventurer):
    def enter_ruins(self):
        self.goal = 5000
        self.diving = True

    def expected_rooms_left(self, state):
        if not self.diving:
            return state.room

        else:
            return (state.stamina - (50 - state.carry_weight)) / 14

    def ratio(self, state, treasure):
        stamina_cost = treasure.weight * (1 + 1/5 * self.expected_rooms_left(state)) + bool(state.players)
        ratio = (treasure.value / (self.goal - state.total_value)) / (stamina_cost / state.stamina)

        return ratio

    def get_action(self, state):
        room, treasures, players, inventory, stamina = state

        if stamina < room * (math.ceil(state.carry_weight / 5) + 10) + 40:
            self.diving = False
            return 'previous'

        worthwhile = []
        for i, treasure in enumerate(treasures):
            ratio = self.ratio(state, treasure)
            if ratio >= 1 and state.carry_weight + treasure.weight <= 50:
                worthwhile.append((ratio, i))

        if worthwhile:
            ratio, index = sorted(worthwhile, reverse=True)[0]
            treasure = treasures[index]
            return 'take', index, treasures[index].weight + bool(players)

        return 'next'

Der Buchhalter ist eine sehr risikoaverse Person. Er möchte sicher sein, dass das, was er tut, in der gegebenen Situation die beste Option ist. Also setzt er sich ein Ziel und sammelt nur dann Schätze, wenn seine Berechnungen zeigen, dass er auf dem richtigen Weg zu diesem Ziel ist. Er ist jedoch sehr bürokratisch und mag es nicht, Gegenstände fallen zu lassen, für die er sich bereits entschieden hat; Alle Versuche, ihm dies beizubringen, führten bisher dazu, dass der Buchhalter einen Gegenstand fallen ließ und ihn unmittelbar danach wieder aufnahm.

Möglicherweise wird fortgesetzt.

Accomodator

Basiert locker auf meinem anderen LightWeight-Bot. Wo Lightweight bietet einfach war, dann ist dies bietet viel komplexer , um zu empfangen Wechselwirkungen mit anderen Bots: sowohl gutartige als auch deliberatly distruptive.

Dieser Bot sprintet zuerst in einen zufällig zugewiesenen Raum und versucht dann, nach dem besten Wert / Gewicht-Verhältnis-Schatz zu bieten. Wenn sich noch andere Spieler im Raum befinden, wird davon ausgegangen, dass sie ebenfalls bieten, statt nach dem zweitbesten Schatz zu bieten. Wenn dieses Gebot fehlschlägt, bieten Sie in der nächsten Runde für den nächstbesten Schatz.

Sobald ein Gebot erfolgreich war, wiederholen Sie das Bieten um das beste / zweitbeste, bis keine Schätze mehr im Raum vorhanden sind, und bewegen Sie sich dann tiefer in die Ruine

Geben Sie für jeden Raum in die Ruine ein und wiederholen Sie das Bieten um das Beste / Zweitbeste, bis keine Schätze mehr im Raum vorhanden sind, und bewegen Sie sich dann tiefer in die Ruine. Wenn wir feststellen, dass wir nicht tiefer gehen können, wechseln Sie in den Status "Verlassen" und beginnen Sie, das Schlimmste fallen zu lassen Schatz, bis wir garantieren können, dass wir die Ruine lebend verlassen können.

Wenn wir den Status verlassen, werden wir prüfen, ob wir 1 kg Schatz hinzufügen können und es trotzdem lebend herausfinden. Wenn dies der Fall ist, werden wir versuchen, auf einen 1 kg Schatz zu bieten. Wenn nicht, werden wir in den vorherigen Raum gehen.

Seine Leistung ist sehr unterschiedlich ... normalerweise wird er jedoch einer der drei besten Bots sein.

import math

class Accomodator(Adventurer):
    def enter_ruins(self):
        self.bidValue = -1
        self.bidWeight = -1
        self.exiting = False
        self.sprintToRoom = self.random.randrange(25,27)
        pass

    def get_action(self, state):
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))
        move_cost_extra_kg = 10 + int(math.ceil((state.carry_weight+1) / 5))

        worstMyTreasure = None
        worstMyTreasureId = -1

        # find our worst treasure
        i=0
        for treasure in state.inventory:
            if (worstMyTreasure is None or treasure.value/treasure.weight < worstMyTreasure.value/worstMyTreasure.weight):
                worstMyTreasure = treasure
                worstMyTreasureId=i
            i+=1

        # are we travelling back to the exit?
        if (self.exiting == True):
          # are we overweight to get back alive?
          if (state.stamina / move_cost < state.room):
            # drop most worthless treasure
            self.bidValue = -1
            self.bidWeight = -1
            return 'drop',worstMyTreasureId

          # would adding one kg cause exhaustion?
          if (state.stamina / move_cost_extra_kg <= state.room ):
            # head back to the exit
            self.bidValue = -1
            self.bidWeight = -1
            return 'previous'

        # sprint if not yet at desired sprintToRoom
        elif (state.room < self.sprintToRoom):
            return 'next'

        # are we now at the limit of stamina to still get back alive?
        if (state.stamina / move_cost <= state.room ):
              self.exiting = True
              # head back to the exit
              self.bidValue = -1
              self.bidWeight = -1
              return 'previous'

        bestRoomTreasure = None
        bestRoomTreasureId = -1
        secondBestRoomTreasure = None
        secondBestRoomTreasureId = -1

        # find the best room treasure
        i=0
        for treasure in state.treasures:
          # when exiting the ruin, only consider treasures to collect that are 1kg inorder
          # to fill up any space left in inventory. Normally consider all treasures
          if (self.exiting == False or treasure.weight == 1):
            # only bid on items that we did not bid on before to avoid bidding deadlock
            if (not (self.bidValue == treasure.value and self.bidWeight == treasure.weight)):
              # consider treasures that are better than my worst treasure or always consider when exiting
              if (self.exiting == True or (worstMyTreasure is None or treasure.value/treasure.weight > worstMyTreasure.value/worstMyTreasure.weight)):
                # consider treasures that are better than the current best room treasure
                if (bestRoomTreasure is None or treasure.value/treasure.weight > bestRoomTreasure.value/bestRoomTreasure.weight):
                    secondBestRoomTreasure = bestRoomTreasure
                    secondBestRoomTreasureId = bestRoomTreasureId
                    bestRoomTreasure = treasure
                    bestRoomTreasureId = i

                    # since we do not currently have any treasures, we shall pretend that we have this treasure so that we can then choose the best treasure available to bid on
                    if (worstMyTreasure is None):
                      worstMyTreasure = bestRoomTreasure
          i+=1

        chosenTreasure = bestRoomTreasure
        chosenTreasureId = bestRoomTreasureId

        # if we have potential competitors then bid on second best treasure
        if (len(state.players)>0 and secondBestRoomTreasure is not None):
          chosenTreasure = secondBestRoomTreasure
          chosenTreasureId = secondBestRoomTreasureId

        # we have chosen a treasure to bid for
        if (chosenTreasure is not None):
            # if the chosenTreasure will not fit then dump the worst treasure
            if (state.carry_weight + chosenTreasure.weight > 50):
              # dump the worst treasure
              self.bidValue = -1
              self.bidWeight = -1
              return 'drop',worstMyTreasureId

            # otherwise lets bid for the treasure!
            self.bidValue = chosenTreasure.value
            self.bidWeight = chosenTreasure.weight
            return 'take',chosenTreasureId,chosenTreasure.weight

        # no treasures are better than what we already have so go to next/previous room
        self.bidValue = -1
        self.bidWeight = -1
        if (self.exiting == False):
          return 'next'
        else:
          return 'previous'

Sprinter

Ähnlich wie der Taucher geht Sprinter in die Tiefe und sammelt die besten Gegenstände auf dem Rückweg ein.

import math


class Sprinter(Adventurer):
    class __OnlyOne:
        __name = None

        def __init__(self, name):
            self.__name = name

        @property
        def name(self):
            return self.__name

        @name.setter
        def name(self, name):
            if self.__name is None:
                self.__name = name
            if self.__name is name:
                self.__name = None

    instance = None

    def set(self, instance):
        if self.instance is not None:
            raise Exception("Already set.")
        self.instance = instance

    def __init__(self, name, random):
        super(Sprinter, self).__init__(name, random)
        if not self.instance:
            self.instance = Sprinter.__OnlyOne(name)

        # else:
        # raise Exception('bye scoundriel')

    def get_action(self, state):
        self.instance.name = self.name
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))
        if state.stamina // move_cost <= state.room + 1:
            return 'previous'
        if state.room < 30 and state.carry_weight < 1:
            return 'next'

        # todo: if there is noone in the room take the most valueable thing that fits criteria

        topVal = 0
        topValIndex = 0
        for t in state.treasures:
            val = t.value / t.weight
            if val > topVal:
                if t.weight + state.carry_weight < 50:
                    topVal = val
                    topValIndex = state.treasures.index(t)

        if len(state.treasures) > topValIndex:
            treasure = state.treasures[topValIndex]
            if treasure.weight + state.carry_weight > 50:  # it doesn't fit
                return 'previous'  # take lighter treasure
            else:
                if topVal > state.room * 2:
                    return 'take', topValIndex, treasure.weight + (self.random.randrange(2, 8) if state.players else 0)

        if state.carry_weight > 0:
            return 'previous'
        else:
            return 'next'

    def enter_ruins(self):
        if self.instance is None or self.name != self.instance.name:
            raise Exception('Hi Scoundrel')

Sprinter geht in die Tiefe, berechnet dann eine Punktzahl für jeden Schatz und nimmt alles auf, was eine bestimmte Schwelle überschreitet. Diese Schwelle hängt von dem Raum ab, in dem er sich gerade befindet, da die Entnahme von Gegenständen aus tiefer gelegenen Räumen mehr kostet.

Ich habe noch 2 Optimierungen in Bezug auf "Fighting for Treasure", die für die nächsten Tage geplant sind.

17.04 .: Scoundrel wurde zu schlau, Sprinter entschloss sich, ihn in eine Falle zu schieben. Anfangs wollte ich jeden Bot töten, der versuchte, Sprinter aufzurufen, aber der Testfahrer handhabt leider keine Ausnahmen, die bei Init auftreten. Das nächste Update für Scoundrel ist also ganz einfach ...

Vorausplanen

import math

class PlanAhead(Adventurer):    
    def get_action(self, state):
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / itm.weight
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop_worst:
            self.drop_worst = False
            return 'drop', worsti[0]
        if self.seenItems:
            ivals = {}
            for i in range(len(self.seenItems)):
                itm = self.seenItems[i][0]
                v = itm.value
                if self.seenItems[i][1] >= state.room:
                    v = 0
                if v / itm.weight > 250: #very likely to get picked up already
                    v = 0
                ivals[i] = v / itm.weight
            bestIiind = max(ivals, key=lambda x: ivals[x])
            bestIi = (bestIiind,
                      self.seenItems[bestIiind][0].value,
                      self.seenItems[bestIiind][0].weight)
        else:
            bestIi = None

        stamCarry = state.carry_weight/5
        stamToExit = state.room * (10 + math.ceil(stamCarry))
        if state.room > self.max_room:
            self.max_room = state.room
        if stamToExit > state.stamina and worsti:
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                v = itm.value
                tvals[i] = v / itm.weight
                self.seenItems.append((itm,state.room))
            besttind = max(tvals, key=lambda x: tvals[x])
            bestt = (besttind,
                     state.treasures[besttind].value,
                     state.treasures[besttind].weight)
            if len(state.players) > 0 and not self.did_drop:
                tvals[besttind] = 0
                besttind = max(tvals, key=lambda x: tvals[x])
                bestt = (besttind,
                         state.treasures[besttind].value,
                         state.treasures[besttind].weight)
        else:
            bestt = None

        if not self.retreat and stamToExit + (12 + stamCarry)*2 + state.room + (state.room/5*state.room) <= state.stamina:
            return 'next'
        if not self.retreat and stamToExit + 10 > state.stamina:
            self.retreat = True
            return 'previous'
        if bestt:
            if state.carry_weight + state.treasures[besttind].weight > 50 or (not self.did_drop and (worsti and (state.treasures[besttind].value-state.treasures[besttind].weight*20) > worsti[1] and state.treasures[besttind].weight <= worsti[2])):
                if worsti:
                    if len(state.players) > 0:
                        return 'previous'

                    if stamToExit <= state.stamina and math.ceil((state.carry_weight - (worsti[2] - state.treasures[besttind].weight))/5)*state.room >= state.treasures[besttind].weight:
                        return 'previous'
                    self.did_drop = True
                    return 'drop', worsti[0]
                else:
                    self.retreat = True
                    return 'previous'
            bid = state.treasures[besttind].weight
            if bid > 8 and state.room >= self.max_room-5:
                return 'previous'
            if not self.did_drop and state.stamina - bid < state.room * (10 + math.ceil(stamCarry+(bid/5))):
                if worsti:
                    if state.treasures[besttind].weight <= worsti[2]:
                        if state.treasures[besttind].value >= worsti[1]:
                            if state.treasures[besttind].weight == worsti[2]:
                                if state.treasures[besttind].value/state.treasures[besttind].weight >= worsti[1]/worsti[2] * (1+(0.05*worsti[2])):
                                    self.drop_worst = True
                                    return 'take', bestt[0], bid
                if not self.retreat:
                    self.retreat = True
                cost = math.ceil((state.carry_weight+bid)/5) - math.ceil(state.carry_weight/5)
                if state.room <= 10 and state.carry_weight > 0 and (state.stamina - stamToExit) >= bid + cost*state.room and bestt:
                    return 'take', bestt[0], bid
                return 'previous'
            self.did_drop = False

            if bestIi[1]/bestIi[2] * 0.3 > bestt[1]/bestt[2] and state.carry_weight > 0:
                return 'previous'
            self.seenItems = list(filter(lambda x: x[0] != state.treasures[besttind], self.seenItems))
            return 'take', bestt[0], bid
        if stamToExit + (12 + stamCarry + state.room)*2 <= state.stamina:
            return 'next'
        else:
            self.did_drop = False
            self.retreat = True
            return 'previous'
    def enter_ruins(self):
        self.retreat = False
        self.max_room = 0
        self.did_drop = False
        self.seenItems = []
        self.drop_worst = False
        pass

Ich habe die besten / schlechtesten Berechnungsmerkmale von Artemis Fowl verwendet , aber die Auswahllogik ist ganz von mir selbst und wurde seitdem geändert, um einige zusätzliche Faktoren zu berücksichtigen, z Schatz, nur um zurückzugehen, ihn fallen zu lassen und etwas anderes aufzuheben).

Bot Ventures, die so tief gehen, wie es für einigermaßen sicher gehalten wird (diese Berechnung funktioniert effektiv bis zu einer bestimmten Tiefe, hat jedoch die Flexibilität, mit anderen anfänglichen Ausdauerwerten umzugehen), sammeln dann Artefakte (priorisieren hohe Kosten und geringes Gewicht) beginnt sich zurückzuziehen, sobald es feststellt, dass es nicht mehr tragen kann.

Auf dem Weg nach draußen sammelt es zusätzliche Schätze, die es sicher zum Ausgang tragen kann. Es wird sogar bereits vorhandene Artefakte fallen lassen, wenn das neue Angebot besser ist und nicht zu Erschöpfung führt. Wenn es Platz im Rucksack hat, wird der neue Schatz aufgesammelt, bevor der niedrigere abgeworfen wird, wodurch der Kampf mit anderen Bots minimiert wird.

Artyventurer

Schlägt die Säufer um etwa 1000 Dollar! Konnte nicht an einen kreativen Namen denken, aber hier sind Sie:

import math, sys, inspect, ntpath, importlib


CONTINUE_IN = 310 #go deeper if I have this much extra 
JUST_TAKE = 0     #take without dropping if I have this much extra 


class Artyventurer(Adventurer): 
    def enter_ruins(self):
        self.drop = False 

    def get_extra(self, state, take=0, drop=0): 
        w = state.carry_weight + take - drop 
        return state.stamina - ((10 + math.ceil(w/5)) * state.room) 

    def get_action(self, state):
        self.fail = 'draco' in ''.join(ntpath.basename(i.filename) for i in inspect.stack())
        if self.fail: 
            return 'previous'
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / (itm.weight + 5)
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop and worsti:
            self.drop = False
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                if itm.weight > (int(state.room/10) or 2):
                    continue
                tvals[i] = itm.weight#(itm.value * (36-state.room)) / (itm.weight * (state.carry_weight+1))
            bestord = sorted(tvals, key=lambda x: tvals[x], reverse=True)
            if bestord:
                pass#print(state.treasures[bestord[0]], '\n', *state.treasures, sep='\n')
            topt = []
            for i in bestord:
                topt.append((i,
                             state.treasures[i].value,
                             state.treasures[i].weight))
        else:
            topt = None
        extra = self.get_extra(state)
        if extra > CONTINUE_IN: 
            return 'next'
        if extra < 0 and worsti:
            return 'drop', worsti[0]
        if extra < state.room:
            return 'previous'
        if extra > JUST_TAKE and topt:
            choose = topt[:len(state.treasures)//3+1]
            for t in choose:
                bid = int(bool(len(state.players)))*3 + t[2]
                if self.get_extra(state, t[2]) - bid >= 0:
                    if t[2] + state.carry_weight <= 50:
                        return 'take', t[0], bid
        if topt and worsti:
            for t in topt[:len(state.treasures)//3+1]:
                if t[1] > worsti[1] or t[2] < worsti[2]:
                    bid = int(bool(len(state.players)))*3 + t[2]
                    if self.get_extra(state, t[2], worsti[2]) - 1 - bid >= 0:
                        print('a', '+weight:', t[2], '; cweight:', state.carry_weight, '; stamina:', state.stamina)
                        if bid < state.stamina and t[2] + state.carry_weight <= 50:
                            print('o')
                            self.drop = True
                            return 'take', t[0], bid
        return 'previous'

Manchmal macht der größte Teil des Codes hier nie etwas (zumindest wenn ich ihn gegen Drunkards teste), das Programm versucht nur den besten Zug zu finden, einschließlich der Verarbeitung für Situationen, in denen es versucht, sich nicht selbst zu versetzen. Einiges davon kann nie laufen, es ist nur da, damit ich mit den Zahlen herumspielen kann, die wahrscheinlich noch verbessert werden können.

Erläuterung

• if state.inventory ... worsti = None
  Finden Sie den 'schlechtesten' Gegenstand im Inventar, dh den Gegenstand mit dem niedrigsten Verhältnis von Wert zu Gewicht. Es speichert worstiden Index, den Wert und das Gewicht als Tupel oder Nonewenn sich keine Gegenstände im Inventar befinden.

• if self.drop ... return 'drop', worsti[0]
  Wenn ich ihm sagte, dass er diese Runde in der letzten Runde fallen lassen soll (siehe unten), kann er den oben berechneten "schlimmsten" Gegenstand fallen lassen.

• extra = ... * state.room
  Berechnen Sie, wie viel Ausdauer es übrig geblieben wäre, wenn ich gesagt hätte, dass es sofort zurückgehen soll.

• if extra > CONTINUE_IN:\ return 'next'
  Wenn es mehr als CONTINUE_IN ist, kehren Sie zurück 'next'.

• if extra < 0 and worsti:\ return 'drop', worsti[0]
  Wenn es kleiner als ist 0, lass das schlechteste Objekt fallen.

• if extra < state.room:\ return 'previous'
  Wenn es weniger als die Zimmernummer ist (kann keinen Schatz mehr tragen), gehe zurück.

• if state.treasures: ... bestt = None
  Finde den besten Schatz, den du nehmen kannst, ähnlich dem schlechtesten Gegenstand im Inventar oben. Speichern Sie es in bestt.

• if extra > 0 and bestt: ... return 'take', bestt[0], bid
  Bei aktuellen Zahlen wird dies ausgeführt, sobald wir soweit sind und ein Schatz verfügbar ist. Wenn es sicher ist, den 'besten' Schatz zu nehmen, tut es das auch. Das Gebot ist das Minimum oder eines mehr, wenn jemand anwesend ist.

• if bestt and worsti: ... return 'take', bestt[0], bid
  Bei aktuellen Nummern wird dieser Codeblock niemals ausgeführt, da der vorherige Codeblock eine umfassendere Bedingung aufweist. Dies wird ausgeführt, wenn wir so weit sind und beide Schätze in meinem Inventar und im Raum sind. Wenn der 'beste' Schatz im Raum wertvoller ist als der 'schlechteste' Schatz in meinem Inventar und es sicher ist, sie in den nächsten zwei Runden zu tauschen, ist dies der Fall.

• return 'previous'
  Wenn nichts davon passiert, gehe einfach zurück.

Update 16.04.19:

Anti-Schurken-Maßnahmen. Dies wird zu einem Bieterkrieg :(

Weiteres Update 16.04.19:

Zurückgesetztes vorheriges, stattdessen wechselt zufällig jedes andere Element, wenn es das beste findet, z. [1, 2, 3, 4, 5, 6] → [2, 1, 3, 4, 6, 5]. Sollte schwerer zu kopieren sein :).

Update 17/04/19:

Vorher zurückgesetzt, löscht es stattdessen seinen eigenen Quellcode . Es tut dies, __init__was immer vorher sein wird Scoundrel.enter_ruins, und hindert Scoundrel daran, es zu laden. Es ersetzt seinen Code, wennget_action ersten Aufruf, damit er für das nächste Mal bereit ist. BEHOBEN, Scoundrel stirbt jetzt bei der Ankunft.

Weiteres Update 17.04.19:

Vorher zurückgesetzt, ersetzt es stattdessen seinen sys.modulesEintrag durch das Mathematikmodul, sodass es stattdessen das Mathematikmodul lädt, wenn Scoundrel versucht, es zu laden. :)
Außerdem habe ich gerade erst gemerkt, dass die Bewegungsausdauer 10 + Gewicht / 5 beträgt , also habe ich versucht, das zu beheben.

Weiteres Update 17.04.19:

Enthält jetzt Knoblauch aus beiden vorherigen Updates.

Update 18.04.19:

Wenn Sie mit Zahlen und Berechnungen experimentieren, erhalten Sie jetzt $ 2000 - $ 3000.

Weitere Aktualisierung 18.04.19:

Entfernt den verbotenen Knoblauch zum Löschen von Dateien und fügt neuen Knoblauch hinzu, der sicherstellt, dass er 'draco'nicht dafür verantwortlich ist, dass er ausgeführt wird, wenn er gerade previousbeim ersten Zug zurückkehrt. Die Ergebnisse haben einen mysteriösen Sprung auf 1200 bis 1800 US-Dollar gemacht, auf den ich mich gerade konzentriere.

Der Schurke

import math, importlib

CONTINUE_IN = 310 #go deeper if I have this much extra 
JUST_TAKE = 0     #take without dropping if I have this much extra 

class Scoundrel(Adventurer):
    def my_import(self, name):
        components = name.split('.')
        mod = __import__(components[0])
        for comp in components[1:]:
            mod = getattr(mod, comp)
        return mod

    def get_action(self, state):
        if self.following == 0:
            return self.sprinter(state)
        if self.following == 1:
            return self.arty(state)
        if self.following == 2:
            return self.account(state)
        return 'next'

    def enter_ruins(self):
        _weights=[17,0,13]
        self.following = self.random.choices(population=[0,1,2],weights=_weights)[0]
        try:
            self.arty_clone = importlib.import_module('artemis_fowl__artyventurer').Artyventurer(self.name,self.random)
            self.arty_clone.enter_ruins()
        except:
            self.arty_clone = None
        self.sprinter_clone = self.my_import('akroell__sprinter').Sprinter(self.name,self.random)
        self.sprinter_clone.enter_ruins()
        self.account_clone = self.my_import('arbo__accountant').Accountant(self.name,self.random)
        self.account_clone.enter_ruins()
        self.drop = False
        pass

    def sprinter(self, state):
        raw_action = self.sprinter_clone.get_action(state)
        if raw_action == 'next' or raw_action == 'previous':
            #move_cost = 10 + int(math.ceil(state.carry_weight / 5))
            #if state.stamina // move_cost < state.room:
            #    print('wont make it!')
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeSprinter(state, *args)
            if atype == 'drop':
                return raw_action
    def TakeSprinter(self, state, treasure, bid):
        move_cost = 10 + int(math.ceil((state.carry_weight+state.treasures[treasure].weight) / 5))
        maxbid = state.stamina - move_cost*(state.room)
        bid = state.treasures[treasure].weight + (7 if state.players else 0)
        if maxbid < state.treasures[treasure].weight:
            return 'previous'
        if maxbid < bid:
            bid = maxbid
        return 'take',treasure, bid

    def arty(self, state):
        if self.arty_clone == None:
            try:
                self.arty_clone = importlib.import_module('artemis_fowl__artyventurer').Artyventurer(self.name,self.random)
                self.arty_clone.enter_ruins()
            except:
                self.arty_clone = None
        if self.arty_clone == None:
            raw_action = self.backup_arty(state)
        else:
            raw_action = self.arty_clone.get_action(state)
        if raw_action == 'previous' and state.carry_weight < 1:
            self.arty_clone.fail = False
            return 'next'
        if raw_action == 'next' or raw_action == 'previous':
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeArty(*args)
            if atype == 'drop':
                return raw_action
    def TakeArty(self, treasure, bid):
        return 'take', treasure, bid + self.random.randrange(0, 2)

    def account(self, state):
        raw_action = self.account_clone.get_action(state)
        if raw_action == 'next' or raw_action == 'previous':
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeAcc(*args)
            if atype == 'drop':
                return raw_action
    def TakeAcc(self, treasure, bid):
        return 'take',treasure,bid + self.random.randrange(0, 2)

    def get_extra(self, state, take=0, drop=0):
        w = state.carry_weight + take - drop
        return state.stamina - ((10 + math.ceil(w/5)) * state.room)
    def backup_arty(self, state):
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / (itm.weight + 5)
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop and worsti:
            self.drop = False
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                if itm.weight > (int(state.room/12) or 2):
                    continue
                tvals[i] = (itm.value * (25-state.room)) / (itm.weight * (state.carry_weight+1))
            bestord = sorted(tvals, key=lambda x: tvals[x])
            topt = []
            for i in bestord:
                topt.append((i,
                             state.treasures[i].value,
                             state.treasures[i].weight))
        else:
            topt = None
        extra = self.get_extra(state)
        if extra > CONTINUE_IN: 
            return 'next'
        if extra < 0 and worsti:
            return 'drop', worsti[0]
        if extra < state.room:
            return 'previous'
        if extra > JUST_TAKE and topt:
            choose = topt[:len(state.treasures)//3+1]
            for t in choose:
                bid = int(bool(len(state.players)))*3 + t[2]
                if self.get_extra(state, t[2]) - bid >= 0:
                    if t[2] + state.carry_weight <= 50:
                        return 'take', t[0], bid
        if topt and worsti:
            for t in topt[:len(state.treasures)//3+1]:
                if t[1] > worsti[1] or t[2] < worsti[2]:
                    bid = int(bool(len(state.players)))*3 + t[2]
                    if self.get_extra(state, t[2], worsti[2]) - 1 - bid >= 0:
                        if bid < state.stamina and t[2] + state.carry_weight <= 50:
                            self.drop = True
                            return 'take', t[0], bid
        return 'previous'

Der Schurke arbeitet hauptsächlich, um andere Teilnehmer zu stören. Derzeit stört es Sprinter, Artyventurer und Accountant (diese Liste wird im Laufe der Zeit erweitert, sofern dies im Interesse des Schurken liegt). Dies geschieht, indem die anderen Bots nachgeahmt werden und dann entweder überboten, unterschnitten oder auf andere Weise um Relikte gekämpft wird. Insofern ist es unwahrscheinlich, dass dieser Eintrag jemals die Rangliste dominiert und stattdessen als verwöhnende Kraft wirkt. Die aktuelle Version zum Zeitpunkt der Veröffentlichung belegt den 2. Platz mit einer durchschnittlichen Punktzahl von ca. 7.

Scoundrel vereitelt den Versuch eines anderen Bots, sich gegen den Scoundrel zu verteidigen, indem er den Code des anderen Teilnehmers direkt als nicht unterscheidbare Klonkopie ausführt. Probleme mit Importen, die zu doppelten Einträgen führten, wurden behoben, indem die Klone über Reflection erstellt wurden (Bearbeitungskriege mit genauen Details der mathematischen Bestimmung sind aus Sicht des Stapelaustauschs nicht wünschenswert, würden jedoch zum gleichen Ergebnis führen). Die KOTH-Herausforderungen haben es in der Vergangenheit auch zugelassen.

Schurke ersetzt die Teamsters, um die Teamsters interessant zu halten. Nach dieser Bearbeitung sollten Teamsters nicht mehr vom Controller geschabt werden.

Update 17.04.2013: Weitere Gegenmaßnahmen.

Die Teamsters (illegal gemacht)

_{Aber fühle dich frei, vor Ort zu rennen, wo es nicht mehr als 8 andere Teilnehmer gibt!}

class TeamsterA(Adventurer):
    def get_action(self, state):
        if state.room < 25 and state.carry_weight == 0:
            return 'next'
        if state.room == 25 and len(state.players) == 0 and len(state.inventory) <= 1:
            if state.treasures and len(state.inventory) == 0:
                tvals = {}
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 1:
                        return 'take',i,1
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 2:
                        return 'take',i,2
            if state.carry_weight > 0 and len(state.inventory) == 1 and int(state.inventory[0].name.strip('Treasure #')) < 500:
                return 'drop',0
            return 'previous'
        if state.room >= 25:
            if (((state.carry_weight+4) / 5) + 10) * state.room >= state.stamina:
                return 'previous'
            if len(state.inventory) == 1 and int(state.inventory[0].name.strip('Treasure #')) < 500:
                return 'drop',0
            if state.treasures:
                tvals = {}
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if int(itm.name.strip('Treasure #')) > 500:
                        if (((state.carry_weight+3+itm.weight) / 5) + 10) * state.room >= state.stamina:
                            return 'previous'
                        return 'take',i,itm.weight
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 1:
                        return 'take',i,1
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 2:
                        return 'take',i,2
                if len(state.inventory) > 0:
                    return 'previous'
                return 'next'
        return 'previous'

class TeamsterB(Adventurer):
    def get_action(self, state):
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                w = itm.weight
                v = itm.value
                if w + state.carry_weight > self.max_total_weight or w > self.max_single_weight:
                    w = 100
                if v / w < state.room * self.min_value_ratio:
                    v = 0
                tvals[i] = v / w
            besttind = max(tvals, key=lambda x: tvals[x])
            bestt = (besttind,
                     state.treasures[besttind].value,
                     state.treasures[besttind].weight)
        else:
            bestt = None
        if state.room < self.max_dive_dist and state.carry_weight == 0:
            return 'next'
        if state.room > 25 and bestt and state.carry_weight + bestt[2] <= self.max_total_weight and bestt[1] > 0 and bestt[2] <= self.max_single_weight and len(state.players) == 0:
            return 'take',bestt[0],bestt[2]
        if state.carry_weight > 0 and state.room > 25 and len(state.players) == 0:
            return 'previous'
        if state.carry_weight > 0:
            return 'drop',0
        if state.carry_weight > 0:
            return 'take',bestt[0],bestt[2]
        return 'previous'
    def enter_ruins(self):
        self.max_single_weight = 3
        self.max_total_weight = 20
        self.min_value_ratio = 2.5
        self.max_dive_dist = 55
        pass

Dieser Eintrag (der jetzt ausdrücklich ungültig ist) ist tatsächlich zwei Bots, und der Controller freut sich schabt sie beide und fügt sie der Kandidatenliste hinzu (weil Hurra, Python?).

Phase 1:

• TeamsterA erreicht Level 25 (ish) ¹ und nimmt wiederholt den leichtesten Schatz, den er finden kann, und lässt ihn fallen. Dies kostet bis zur zweiten Phase satte 1 Ausdauer pro Runde.
• TeamsterB geht zu Level 55 und nimmt alle herumliegenden Wertsachen auf und geht dann zurück zu Level 25 (ish). ² Dann beginnt Phase 2.

<sub>1. Wenn es keinen Schatz gibt, der weniger als 3 wiegt, bewegt er sich nach unten.
2. Da er so ziemlich garantiert der letzte ist Abenteurer ist, der an die Oberfläche zurückkehrt, muss er nur jemanden finden.</sub>

Phase 2:

• TeamsterB leert seine Taschen, bevor er vor Erschöpfung davonkriecht. Wir wussten, dass Sie es schaffen könnten.
• TeamsterA denkt, "das sind ein paar glänzende Schmuckstücke, guter Kumpel, alter Kumpel!" und beladen Sie die viel wertvolleren Schätze als den anderen Müll im Raum, bevor Sie mit Taschen voller Gold zum Ausgang gehen.

Der Name der Schätze erwies sich als nützlich, um der Logik zu helfen, keinen Müll auf Etage 25 zu laden und früh zu verschwinden, da es keine Möglichkeit gab, zwischen den beiden Bots zu kommunizieren (und TeamsterA befand sich vorher immer in einem Raum mit jemand anderem TeamsterB war zurückgekehrt).

Die nächste logische Schlussfolgerung: Eine Armee aufstellen

Theoretisch könnte dies verwendet werden, um die Tiefen auszuloten und Schätze aus der Tiefe von Raum 98 zu sammeln. Da dies jedoch mehr als zwei Bots erfordern würde, würde die Logik, die diese Bots umfasst, immer komplexer, und da ich mir sicher bin, dass dies der Fall ist eine illegale Einreichung wegen Verstoßes gegen eine ungeschriebene Regel, also werde ich mich nicht darum kümmern.

AWartet effektiv um 30, Bwartet um 50 ... nspringt auf 98, nimmt einen Schatz auf, geht auf 97, lässt ihn fallen (und stirbt dann), n-1nimmt ihn auf und geht auf 96 ... Clässt ihn fallen (stirbt), Bholt ihn ab auf und geht auf 30, lässt es fallen (stirbt),A nimmt es auf und kehrt zum Ausgang zurück.

Ich schätze, dass dies 11 Bots dauern würde.

Es lohnt sich jedoch nicht, es sei denn, Sie können ungefähr 4 Schätze aus dieser Tiefe bergen, um mit Einträgen wie PlanAhead oder Artyventure zu konkurrieren. Dies liegt an der Skalierung zwischen den Ausdauer-Bewegungskosten und dem Durchschnittswert der Schätze.

Probenergebnisse

Erzielt selten weniger als 4000 US-Dollar und erreicht gelegentlich 6000 US-Dollar.

[Turn 141] Homer the Great (TeamsterA) exited the ruins with 286 stamina
    and 16 treasures, totaling $4900 in value.
[Game End] The game has ended!
[Game End] Homer the Great (TeamsterA) won the game

[Turn 145] Samwell Jackson DDS (TeamsterA) exited the ruins with 255 stamina
    and 20 treasures, totaling $6050 in value.
[Game End] The game has ended!
[Game End] Samwell Jackson DDS (TeamsterA) won the game

[Turn 133] Rob the Smuggler (TeamsterA) exited the ruins with 255 stamina
    and 12 treasures, totaling $3527 in value.
[Game End] The game has ended!
[Game End] Eliwood the Forgettable (PlanAhead) won the game

Rückwärts

_{Weil es umgekehrt funktioniert}

import math

class Backwards (Adventurer):
    def enter_ruins(self):
        self.goal = 5000
        self.diving = True

    def expected_rooms_left(self, state):
        if not self.diving:
            return state.room
        else:
            return state.stamina / 18

    def ratio(self, state, treasure):
        stamina_cost = treasure.weight * (1 + 1/5 * self.expected_rooms_left(state)) + math.ceil(len(state.players)/2.9)
        ratio = (treasure.value / (self.goal - state.total_value)) / (stamina_cost / state.stamina)
        return ratio

    def get_action(self, state):
        room, treasures, players, inventory, stamina = state
        if stamina < room * (math.ceil(state.carry_weight / 5) + 10) + 40 or stamina < (room+2.976) * (math.ceil(state.carry_weight / 5) + 11):
            self.diving = False
        if stamina < (room+0.992) * (math.ceil(state.carry_weight / 5) + 10.825):
            return 'previous'

        worthwhile = []
        for i, treasure in enumerate(treasures):
            ratio = self.ratio(state, treasure)
            if ratio >= 1 and state.carry_weight + treasure.weight <= 50:
                worthwhile.append((ratio, i))

        if worthwhile:
            ratio, index = sorted(worthwhile, reverse=True)[0]
            treasure = treasures[index]
            bid = treasures[index].weight + math.ceil(len(players)/2.9)
            if (not self.diving or ratio > 2.8) and stamina >= bid + (room) * (math.ceil((state.carry_weight+treasures[index].weight) / 5) + 10):
                return 'take', index, bid
        return 'next' if self.diving else 'previous'

Warum heißt es Rückwärts?

Weil ich den Buchhalter mitgenommen habe und versucht habe, ihn so zu logisieren, dass er tief taucht und dann seine bevorzugte Beute auf dem Weg nach draußen aufnimmt (rückwärts vom Buchhalter).

Am Ende sammelt es immer noch einen Großteil seiner Preise auf dem Weg hinein (es schöpft sie aus, bevor es die traditionellen In-Collect-Out-Sucher tun, die rückwärts zu allen anderen agieren), aber es ist viel selektiver welche es nimmt, obwohl es immer noch nimmt Dinge auf dem Rückweg auf.

Das Endergebnis ist, dass die Ausdauer auf dem Weg nach innen erhalten bleibt, während immer noch hochwertige Schätze im Vordergrund stehen. Auf dem Weg nach oben profitieren Sie dann von einer tiefen Wendung und einer leichten Ernte. Es ist bekannt, dass Rückwärts Schätze aus der Tiefe von Raum 41 sammelt (und während der Entwicklung Raum 42 betritt und dann sofort verlässt).

Kopfgeldjäger

Die einfache Methode ist die beste. Sammle wertvolle und leichte Schätze und gehe dabei so tief wie möglich. Besorgen Sie sich auf dem Rückweg weniger wertvolle Schätze.

import math

class BountyHunter(Adventurer):
    def move_cost(self, state, additional_weight):
        return 10 + int(math.ceil((state.carry_weight + additional_weight) / 5))

    def get_action(self, state):
        can_go_deeper = state.stamina > (state.room + 2) * self.move_cost(state, 0)
        if state.treasures:
            best_ratio = 0
            best_index = 0
            best_weight = 0
            for i, treasure in enumerate(state.treasures):
                ratio = treasure.value / treasure.weight
                if ratio > best_ratio:
                    best_ratio = ratio
                    best_index = i
                    best_weight = treasure.weight
            limit = 160 if can_go_deeper else 60
            bid = best_weight + 2 if len(state.players) >= 1 else best_weight
            if state.carry_weight + best_weight <= 50 and best_ratio >= limit and state.stamina >= bid + state.room * self.move_cost(state, best_weight):
                return 'take', best_index, bid
        if can_go_deeper:
            return 'next'
        else:
            return 'previous'

Leicht

Ein einfacher Bot, der immer noch recht gut abschneidet.

Nach dem Betreten der Ruinen (derzeit 21 Räume) wird der beste Schatz im Raum gefunden, der nur 1 kg wiegt (daher der Name des Bots) und wertvoller ist als der am wenigsten wertvolle Schatz im Inventar. Wenn das Inventar voll ist, lasse den am wenigsten wertvollen Schatz fallen. Wenn keine andere Aktion ausgewählt ist, erfolgt der Einzug in die Ruinen. Wenn wir an der Grenze unserer Ausdauer sind, um lebend herauszukommen, begeben wir uns zum Ausgang

import math

class LightWeight(Adventurer):

    def get_action(self, state):
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))

        # are we now at the limit of stamina to still get back alive?
        if (state.stamina / move_cost <= state.room + 3):
            # head back to the exit
            return 'previous'

        if (state.room < 21):
            return 'next'

        bestRoomTreasure = None
        bestRoomTreasureId = -1
        worstMyTreasure = None
        worstMyTreasureId = -1

        # find our worst treasure
        i=0
        for treasure in state.inventory:
            if (worstMyTreasure is None or treasure.value < worstMyTreasure.value):
                worstMyTreasure = treasure
                worstMyTreasureId=i
            i+=1

        # we have hit our carrying capacity... we are now going to dump least valuable treasure
        if (state.carry_weight==50):

            # dump the worst treasure
            return 'drop',worstMyTreasureId

        # find the best room treasure
        i=0
        for treasure in state.treasures:
            if (treasure.weight == 1 and (worstMyTreasure is None or treasure.value > worstMyTreasure.value)):
                if (bestRoomTreasure is None or treasure.value > bestRoomTreasure.value):
                    bestRoomTreasure = treasure
                    bestRoomTreasureId = i
            i+=1

        # we have found a treasure better than we already have!
        if (bestRoomTreasure is not None):
            return 'take',bestRoomTreasureId,1

        # no treasures are better than what we already have so go to next room
        return 'next'

Auswendiglernen

Ich kann Bots an meine eigene KotH senden, oder?

from __main__ import Adventurer
import math
from collections import namedtuple

class TooHeavy(Exception):
    pass

TreasureNote = namedtuple(
    'TreasureNote',
    ['utility', 'cost', 'room', 'name', 'value', 'weight']
)

def find_treasure(treasures, name):
    for i, t in enumerate(treasures):
        if t.name == name:
            return i, t
    raise KeyError(name)

EXPLORE_DEPTH = 30
TRINKET_MINIMUM_VALUE = 60

class Memorizer(Adventurer):
    def enter_ruins(self):
        self.seen = []
        self.plan = []
        self.backups = []
        self.diving = True
        self.dive_grab = False

    def plan_treasure_route(self, state):
        self.plan = []
        self.backups = []
        weight = state.carry_weight
        for treasure in self.seen:
            if weight + treasure.weight <= 50:
                self.plan.append(treasure)
                weight += treasure.weight
            else:
                self.backups.append(treasure)
        room_utility = lambda t: (t.room, t.utility)
        self.plan.sort(key=room_utility, reverse=True)

    def iter_backups(self, state):
        names = {t.name for t in state.treasures}
        owned = {t.name for t in state.inventory}
        for treasure in self.backups:
            if (treasure.room == state.room
                    and treasure.name in names
                    and treasure.name not in owned):
                yield treasure

    def take(self, state, name):
        index, treasure = find_treasure(state.treasures, name)
        if state.carry_weight + treasure.weight > 50:
            raise TooHeavy(name)
        if state.players:
            bid_bonus = self.random.randrange(len(state.players) ** 2 + 1)
        else:
            bid_bonus = 0
        return 'take', index, treasure.weight + bid_bonus

    def get_action(self, state):
        take_chance = 0.9 ** len(state.players)

        if self.diving:
            if self.dive_grab:
                self.dive_grab = False
            else:
                self.seen.extend(
                    TreasureNote(
                        value / weight,
                        weight + math.ceil(weight / 5) * state.room,
                        state.room,
                        name, value, weight
                    )
                    for name, value, weight in state.treasures
                )
            if state.room < EXPLORE_DEPTH:
                if len(state.inventory) < 5:
                    trinkets = [
                        t for t in state.treasures
                        if t.weight == 1
                        and t.value >= TRINKET_MINIMUM_VALUE
                    ]
                    trinkets.sort(key=lambda t: t.value, reverse=True)
                    for candidate in trinkets:
                        if self.random.random() < 0.99 ** (len(state.players) * state.room):
                            try:
                                action = self.take(state, candidate.name)
                            except (KeyError, TooHeavy):
                                pass # WTF!
                            else:
                                self.dive_grab = True
                                return action
                return 'next'
            else:
                self.diving = False
                self.seen.sort(reverse=True)
                self.plan_treasure_route(state)

        carry_weight = state.carry_weight
        if carry_weight == 50:
            return 'previous'

        if self.plan:
            next_index = 0
            next_planned = self.plan[next_index]
            if state.room > next_planned.room:
                return 'previous'

            try:
                while state.room == next_planned.room:
                    if self.random.random() < take_chance:
                        try:
                            return self.take(state, next_planned.name)
                        except (KeyError, TooHeavy):
                            self.plan.pop(next_index)
                            next_planned = self.plan[next_index]
                    else:
                        next_index += 1
                        next_planned = self.plan[next_index]
            except IndexError:
                pass
        else:
            next_planned = TreasureNote(0, 0, 0, 0, 0, 0)

        for candidate in self.iter_backups(state):
            if candidate.utility * 2 > next_planned.utility and self.random.random() < take_chance:
                try:
                    return self.take(state, candidate.name)
                except (KeyError, TooHeavy):
                    pass

        return 'previous'

Dieser Bot taucht in Raum 30 und merkt sich alle Schätze, die er gesehen hat. An diesem Punkt beginnt er seinen Rückweg zum Eingang und versucht, gute Schätze zu sammeln, an die er sich in früheren Räumen erinnert hatte.

Ich hoffte, es würde besser gehen. Mögliche Verbesserungen ergeben sich möglicherweise aus einer besseren Planung und einer dynamischeren Ermittlung des Raums, in dem nicht mehr getaucht wird, sowie aus einer größeren Bereitschaft, die Backup-Optionen zu prüfen.

Update: Schnappt euch jetzt 1 kg Schätze im Wert von 60 USD oder mehr.

Ponderer

Ich denke, es ist Memorizer ziemlich ähnlich, da es die Kenntnis der besuchten Räume verwendet, um auszuwählen, welche Räume und Schätze auf dem Weg zurück zum Ausgang gesammelt werden sollen. Es wurde jedoch unabhängig abgeleitet.

Dieser Bot sprintet, bis ein zufälliger tiefer Raum eine Aufzeichnung der unterwegs gefundenen Schätze aufnimmt. Sobald es im Zielraum angekommen ist, wird es über die ideale Auswahl an Schätzen nachdenken , die es auf dem Weg zurück zum Ausgang findet. Jede Runde wird es erneut nachgedacht , um die wahrscheinlich beste Auswahl an Schätzen zu finden.

Derzeit gibt es einen einfachen Algorithmus (Potenz der Raumnummer umgekehrt), der die angenommene Anzahl an Schätzen ergibt, die für jeden Raum genommen wurden (oder genommen wurden, wenn dieser Bot ihn besucht). Diese Schätze werden ignoriert, wenn über welche Schätze / Räume nachgedacht wird zu nehmen aus. Ich habe Ideen für andere fortgeschrittene Algorithmen, um zu modellieren, welche Schätze noch vorhanden sind. Aber ich werde sehen müssen, ob sich der Nutzen lohnt.

import math

class Ponderer(Adventurer):

  class PondererTreasure:
    def __init__(self):
        self.weight = 0
        self.value = 0
        self.id = -1
        pass

  class PondererRoom:
    def __init__(self):
        self.treasures = []
        pass

  def enter_ruins(self):
      self.exiting = False
      self.sprintToRoom = self.random.randrange(30,33)
      self.rooms = {}
      self.roomsToSkip = 0
      pass

  def getBestEstimatedFinalValue(self, roomId, carry_weight, stamina, action, valueCache):
    if (roomId<=0):
      return 0

    roomValueCache = valueCache.get(roomId)

    if (roomValueCache is None):
      roomValueCache = {}
      valueCache[roomId] = roomValueCache

    value = roomValueCache.get(carry_weight)
    if (value is None):
      room = self.rooms.get(roomId)

      bestTreasureValue = 0
      bestTreasure = None
      treasures = []
      treasures.extend(room.treasures)
      skipRoomTreasure = Ponderer.PondererTreasure()
      treasures.append(skipRoomTreasure)

      roomFactor = 0.075*roomId
      estimatedTreasuresTakenAtCurrentRoom =  int(min(0.5 * len(room.treasures), max(1, 0.5 * len(room.treasures)*(1.0/(roomFactor*roomFactor)))))

      j=0
      for treasure in treasures:
        if (j>=estimatedTreasuresTakenAtCurrentRoom):
          staminaAfterBid = stamina - treasure.weight
          carry_weightAfterBid = carry_weight + treasure.weight
          move_costAfterBid = 10 + int(math.ceil(carry_weightAfterBid/5))

          if (carry_weightAfterBid <=50 and (staminaAfterBid/move_costAfterBid > roomId+1)):
            bestAccumulativeValue = self.getBestEstimatedFinalValue(roomId-1, carry_weightAfterBid, staminaAfterBid - move_costAfterBid, None, valueCache)

            if (bestAccumulativeValue >= 0):
              bestAccumulativeValue += treasure.value
              if (bestTreasure is None or bestAccumulativeValue > bestTreasureValue):
                bestTreasureValue = bestAccumulativeValue
                bestTreasure = treasure
        j+=1

      if (bestTreasure == skipRoomTreasure):
        if (action is not None):
          newAction = []
          newAction.append('previous')
          action.append(newAction)
        value = 0

      elif (bestTreasure is not None):
        if (action is not None):
          newAction = []
          newAction.append('take')
          newAction.append(bestTreasure.id)
          newAction.append(bestTreasure.weight)
          action.append(newAction)
        value = bestTreasureValue

      else:
        if (action is not None):
          newAction = []
          newAction.append('previous')
          action.append(newAction)
        value = -1

      roomValueCache[carry_weight] = value
    return value

  def get_action(self, state):
    room = Ponderer.PondererRoom()

    i=0
    for treasure in state.treasures:
      pondererTreasure = Ponderer.PondererTreasure()
      pondererTreasure.weight = treasure.weight
      pondererTreasure.value = treasure.value
      pondererTreasure.id = i

      room.treasures.append(pondererTreasure)
      i+=1

    room.treasures.sort(key=lambda x: x.value/x.weight, reverse=True)

    self.rooms[state.room] = room

    if (self.exiting == False and state.room < self.sprintToRoom):
      return 'next'

    self.exiting = True

    action = []
    valueCache = {}

    self.getBestEstimatedFinalValue(state.room, state.carry_weight, state.stamina, action, valueCache)

    if (action[0][0] == 'take'):
      return 'take', action[0][1], action[0][2]

    return action[0][0]

Hamsterer

import math

class Hoarder(Adventurer):
  def canGoOn(self, state):
    costToMove = 10 + math.ceil(state.carry_weight / 5)
    return (state.room + 2) * costToMove <= state.stamina

  def canTakeTreasure(self, state, treasure):
    costToMove = 10 + math.ceil(state.carry_weight / 5)
    treasureCost = treasure.weight + 1
    return treasureCost + state.room * costToMove <= state.stamina

  def get_action(self, state):
    if (len(state.treasures) == 0):
      if (self.canGoOn(state)):
        return "next"
      else:
        return "previous"
    else:
      bestTreasure = -1
      for i, treasure in enumerate(state.treasures):
        if self.canTakeTreasure(state, treasure):
          if (bestTreasure == -1):
            bestTreasure = i
          elif state.treasures[bestTreasure].value < state.treasures[i].value:
            bestTreasure = i
      if (bestTreasure == -1):
        return "previous"
      return "take", bestTreasure, state.treasures[bestTreasure].weight+1

Der Hamsterer bleibt in einem Raum, bis er alle Schätze im Raum genommen hat (oder berechnet, dass er nicht genug Ausdauer hat, um weiterzumachen). Wenn alle Schätze verschwunden sind und der Bot sich sicher fortbewegen kann, wird er den Prozess fortsetzen, alle Schätze zu nehmen.

Taucher

(Kann im Moment nicht testen, lass es mich wissen, wenn dies kaputt ist.)

class Diver(Adventurer):
    def get_action(self, state):
        # Don't take anything on the way in.
        if state.stamina > 700:
            return 'next'

        # Take the most valuable thing we can take without dying.
        for treasure in sorted(state.treasures, key=lambda x: x.value, reverse=True):
            total = treasure.weight + state.carry_weight
            if total <= 50 and (10 + (total + 4) // 5) * state.room + treasure.weight <= state.stamina:
                return 'take', state.treasures.index(treasure), treasure.weight

        # If there's nothing else we can do, back out.
        return 'previous'

Der beste Schatz liegt tiefer in den Ruinen. Tauchen Sie also tief ein und holen Sie sich auf dem Weg nach draußen, was wir können.