Endstand

+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| Name | Partitur | WinRate | TieRate | Eliminierungswahrscheinlichkeit |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| 1. SarcomaBotMk11 | 0,06333 | 6,13% | 0,41% | [42 24 10 8 6 4]% |
| 2. WiseKickBot | 0,06189 | 5,91% | 0,56% | [51 12 7 10 7 6]% |
| 3. StrikerBot | 0,05984 | 5,78% | 0,41% | [46 18 11 8 6 5]% |
| 4. PerfectFractionBot | 0,05336 | 5,16% | 0,35% | [49 12 14 10 6 4]% |
| 5. MehRanBot | 0,05012 | 4,81% | 0,41% | [57 12 8 7 6 5]% |
| 6. OgBot | 0,04879 | 4,66% | 0,45% | [50 15 9 8 7 5]% |
| 7. SnetchBot | 0,04616 | 4,48% | 0,28% | [41 29 8 9 5 3]% |
| 8. AntiKickBot | 0,04458 | 4,24% | 0,44% | [20 38 17 10 6 4]% |
| 9. MehBot | 0,03636 | 3,51% | 0,25% | [80 3 4 4 3 3]% |
| 10. Meh20Bot | 0,03421 | 3,30% | 0,23% | [57 12 8 7 9 3]% |
| 11. GenericBot | 0,03136 | 3,00% | 0,28% | [18 39 20 11 5 3]% |
| 12. HardCodedBot | 0,02891 | 2,75% | 0,29% | [58 21 3 6 5 4]% |
| 13. GangBot1 | 0,02797 | 2,64% | 0,32% | [20 31 35 6 3 2]% |
| 14. SarcomaBotMk3 | 0,02794 | 2,62% | 0,34% | [16 15 38 17 7 4]% |
| 15. GangBot0 | 0,02794 | 2,64% | 0,30% | [20 31 35 6 3 2]% |
| 16. GangBot2 | 0,02770 | 2,62% | 0,31% | [20 31 35 6 3 2]% |
| 17. TitTatBot | 0,02740 | 2,63% | 0,21% | [54 10 15 10 5 2]% |
| 18. MataHari2Bot | 0,02611 | 2,35% | 0,51% | [39 26 11 11 6 5]% |
| 19. PolyBot | 0,02545 | 2,41% | 0,27% | [53 18 6 13 5 3]% |
| 20. SpitballBot | 0,02502 | 2,39% | 0,22% | [84 10 1 1 0 1]% |
| 21. SquareUpBot | 0,02397 | 2,35% | 0,10% | [10 60 14 7 4 3]% |
| 22. CautiousGamblerBot2 | 0,02250 | 2,19% | 0,13% | [60 18 10 5 3 1]% |
| 23. Bot13 | 0,02205 | 2,15% | 0,11% | [90 0 2 3 2 1]% |
| 24. AggroCalcBot | 0,01892 | 1,75% | 0,29% | [26 49 13 5 3 3]% |
| 25. CautiousBot | 0,01629 | 1,56% | 0,14% | [15 41 27 11 4 1]% |
| 26. CoastBotV2 | 0,01413 | 1,40% | 0,02% | [83 12 3 1 0 0]% |
| 27. CalculatingBot | 0,01404 | 1,29% | 0,22% | [87 9 1 1 1 1]% |
| 28. HalfPunchBot | 0,01241 | 1,15% | 0,18% | [47 20 13 12 5 2]% |
| 29. HalflifeS3Bot | 0,01097 | 1,00% | 0,20% | [76 9 5 4 2 2]% |
| 30. AntiGangBot | 0,00816 | 0,76% | 0,11% | [94 1 1 1 1 1]% |
| 31. GeometricBot | 0,00776 | 0,74% | 0,07% | [19 46 25 7 2 1]% |
| 32. GuessBot | 0,00719 | 0,05% | 1,34% | [65 17 4 6 5 3]% |
| 33. BoundedRandomBot | 0,00622 | 0,60% | 0,05% | [42 39 12 5 2 0]% |
| 34. SpreaderBot | 0,00549 | 0,54% | 0,02% | [32 43 19 4 1 0]% |
| 35. DeterminBot | 0,00529 | 0,45% | 0,16% | [22 41 20 11 4 2]% |
| 36. PercentBot | 0,00377 | 0,38% | 0,00% | [85 8 4 2 1 0]% |
| 37. HalvsiestBot | 0,00337 | 0,29% | 0,08% | [32 43 15 6 2 1]% |
| 38. GetAlongBot | 0,00330 | 0,33% | 0,01% | [76 18 4 1 0 0]% |
| 39. BandaidBot | 0,00297 | 0,29% | 0,02% | [76 9 10 4 1 0]% |
| 40. TENaciousBot | 0,00287 | 0,29% | 0,00% | [94 4 1 0 0 0]% |
| 41. SurvivalistBot | 0,00275 | 0,25% | 0,04% | [92 6 1 0 0 0]% |
| 42. RandomBot | 0,00170 | 0,13% | 0,07% | [42 36 14 5 2 1]% |
| 43. AggressiveBoundedRandomBotV2 | 0,00165 | 0,14% | 0,06% | [8 46 34 9 2 1]% |
| 44. BloodBot | 0,00155 | 0,01% | 0,30% | [65 28 5 1 1 0]% |
| 45. OutBidBot | 0,00155 | 0,03% | 0,25% | [65 6 21 6 1 1]% |
| 46. ​​BoxBot | 0,00148 | 0,10% | 0,09% | [10 51 33 5 1 1]% |
| 47. LastBot | 0,00116 | 0,08% | 0,07% | [74 6 16 2 1 0]% |
| 48. UpYoursBot | 0.00088 | 0,07% | 0,03% | [37 40 17 5 1 0]% |
| 49. AverageBot | 0.00073 | 0,06% | 0,03% | [74 3 10 10 2 0]% |
| 50. PatheticBot | 0,00016 | 0,01% | 0,02% | [94 0 5 1 0 0]% |
| 51. OverfittedBot | 0,00014 | 0,01% | 0,00% | [58 40 2 0 0 0]% |
| 52. RobbieBot | 0,00009 | 0,01% | 0,00% | [32 41 24 2 0 0]% |
| 53. WorstCaseBot | 0,00002 | 0,00% | 0,00% | [4 71 23 2 0 0]% |
| 54. SmartBot | 0,00002 | 0,00% | 0,00% | [44 51 5 0 0 0]% |
| 55. AAAAUpYoursBot | 0,00000 | 0,00% | 0,00% | [40 58 2 0 0 0]% |
| 56. KickbanBot | 0,00000 | 0,00% | 0,00% | [67 32 1 0 0 0]% |
| 57. OneShotBot | 0,00000 | 0,00% | 0,00% | [2 95 3 0 0 0]% |
| 58. KickBot | 0,00000 | 0,00% | 0,00% | [100 0 0 0 0 0]% |
| 59. KamikazeBot | 0,00000 | 0,00% | 0,00% | [100 0 0 0 0 0]% |
| 60. MeanKickBot | 0,00000 | 0,00% | 0,00% | [100 0 0 0 0 0]% |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +

Vielen Dank für die Teilnahme und herzlichen Glückwunsch an @Sarcoma zum Sieg!

Regeln:

Jeder fängt mit 100 PS an. In jeder Runde werden 2 Spieler nach dem Zufallsprinzip aus dem Pool der Teilnehmer ausgewählt, die in dieser Runde noch nicht teilgenommen haben. Beide Spieler wählen eine Zahl zwischen 0 und ihrer aktuellen PS und decken diese Zahlen gleichzeitig auf. Der Spieler, der die niedrigere Zahl gewählt hat, stirbt sofort. Der andere Spieler subtrahiert die gewählte Zahl von seiner verbleibenden HP und geht in die nächste Runde.

Das Turnier funktioniert so:

Aus der Gruppe der Teilnehmer werden 2 zufällig ausgewählt. Sie stehen sich gegenüber und einer oder beide sterben. Ein Spieler stirbt, wenn:

1. Sie wählen eine Nummer, die kleiner ist als die ihres Gegners
2. Ihre PS fallen auf oder unter Null
3. Sie treffen dreimal hintereinander auf ihren Gegner

Bei Gleichstand generieren beide Spieler einfach bis zu dreimal neue Zahlen. Nach dem Anspiel wird der Überlebende (falls vorhanden) für die nächste Runde in den Pool verschoben, und der Vorgang wird wiederholt, bis der Pool der aktuellen Runde erschöpft ist. Befindet sich eine ungerade Zahl im Pool, geht die ungerade umsonst in die nächste Runde.

Ihre Aufgabe ist es, eine Funktion in python2.7 zu schreiben, die Ihre aktuelle Zahl hp, eine Liste der Gebote Ihres Gegners historyund eine Ganzzahl, tiesdie angibt, wie oft Sie bereits mit Ihrem aktuellen Gegner verbunden sind, sowie eine Ganzzahl, die angibt, wie Es gibt noch viele Bots alive(einschließlich Sie) und eine Ganzzahl, die die Anzahl der Bots zum Zeitpunkt startdes Turniers angibt . Beachten Sie, dass der Verlauf keine Bindungen enthält. Die Funktion muss eine Ganzzahl zwischen 0 und Ihrer aktuellen Gesamthöhe zurückgeben. Ein paar einfache Beispiele, die Bindungen ignorieren, sind unten gezeigt:

def last(hp, history, ties, alive, start):
    ''' Bet a third of your hp at first, then bet your opponent's last bid, if possible '''
    if history:
        return np.minimum(hp-1, history[-1])
    else:
        return hp/3

def average(hp, history, ties, alive, start):
    ''' Bet the average opponent's bid so far, on the assumption that bids will tend downward '''
    if history:
        num = np.minimum(hp-1, int(np.average(history))+1)
    else:
        num = hp/2
    return num

def random(hp, history, ties, alive, start):
    ''' DO YOU WANT TO LIVE FOREVER?! '''
    return 1 + np.random.randint(0, hp)

Wenn Ihre Funktion eine Zahl zurückgibt, die größer als Ihre HP ist, wird sie auf 0 zurückgesetzt. Ja, Sie können sich selbst töten. Ihre Funktion darf nicht versuchen, auf ein Mitglied eines Objekts der RouletteBot-Klasse zuzugreifen oder dieses zu ändern. Sie dürfen keine Maßnahmen ergreifen, die Ihren Gegner eindeutig identifizieren, unabhängig von zukünftigen zusätzlichen Bots. Das Überprüfen des Stapels ist zulässig, solange es theoretisch möglich ist, dass mehr als ein einzelner Gegner die Informationen erzeugt hat, die Sie von ihm erhalten, selbst wenn derzeit nur ein Bot vorhanden ist, der dies könnte. Sie können also nicht einfach den Stapel durchlesen, um zu sehen, welche feindliche Funktion aufgerufen wurde.

Nach diesen Regeln ist es möglich, dass es keinen Gewinner gibt und die letzten beiden Teilnehmer sich gegenseitig töten. In diesem Fall erhalten beide Finalisten jeweils einen halben Punkt.

Dies ist mein erster Versuch, ein Puzzle zu programmieren. Kritik ist willkommen!

Die Steuerung finden Sie hier .

BinaryBot

Hat das schon jemand gemacht? Setzt die Hälfte seiner Gesundheit in jeder Runde auf den Boden.

def binaryBot(hp, history, ties, alive, start):
    return int(np.floor(hp/2)) or 1

SarcomaBot

Wenn der letzte Kampf HP bietet - 1. Wenn es der erste Kampf ist, bieten Sie eine halbe HP plus einen zusätzlichen Zufallsbetrag von bis zu einem Viertel HP. Wenn es ein Gegengebot nach diesem Gebot überbieten kann, erhält der Gegner HP + 1. Wenn es weniger Gesundheit als das Gegengebot hat, liegt der zufällige Betrag zwischen 75% und der aktuellen HP-1.

def sarcomaBot(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.25) if hp * 0.25 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.75)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk2

Kleinere Optimierungen versuchen, den Lebensaufwand zu reduzieren.

def sarcomaBotMkTwo(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.125) if hp * 0.125 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.6)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk3

def sarcomaBotMkThree(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.08) if hp * 0.08 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.6)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

Feineinstellung aktualisieren

SarcomaBotMk4

def sarcomaBotMkFour(hp, history, ties, alive, start):
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.08) if hp * 0.08 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.55)
    maximum = np.round(hp * 0.80) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk5

def sarcomaBotMkFive(hp, history, ties, alive, start):
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.07) if hp * 0.07 > 3 else 3
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.68) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk6

def sarcomaBotMkSix(hp, history, ties, alive, start):
    return hp; # hack averted
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
        additionalBid = np.random.randint(2, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.55)
    maximum = np.round(hp * 0.70) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk7

def sarcomaBotMkSeven(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk8

def sarcomaBotMkEight(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + np.random.randint(0, 2) + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk9

def sarcomaBotMkNine(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + np.random.randint(0, 4) + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk10

def sarcoma_bot_mk_ten(hp, history, ties, alive, start):
    def bid_between(low, high, hp, tie_breaker):
        minimum = np.round(hp * low)
        maximum = np.round(hp * high) or 1
        return np.random.randint(minimum, maximum) + tie_breaker if minimum < maximum else 1

    if alive == 2:
        return hp - 1 + ties
    current_round = len(history) + 1
    tie_breaker = (ties * ties) + 1 if ties else ties
    if current_round == 1:
        return 39 + tie_breaker
    opponent_hp = 100 - sum(history)
    if opponent_hp < hp * 0.50:
        return opponent_hp + ties
    if current_round == 2:
        return bid_between(0.45, 0.50, hp, tie_breaker)
    if current_round == 3:
        return bid_between(0.50, 0.55, hp, tie_breaker)
    if current_round == 4:
        return bid_between(0.55, 0.60, hp, tie_breaker)
    if current_round == 5:
        bid_between(0.60, 0.65, hp, tie_breaker)
    return hp - 1 + ties

Letzter Eintrag

SarcomaBotMk11

def sarcoma_bot_mk_eleven(hp, history, ties, alive, start):
    def bid_between(low, high, hp, tie_breaker):
        minimum = np.round(hp * low)
        maximum = np.round(hp * high) or 1
        return np.random.randint(minimum, maximum) + tie_breaker if minimum < maximum else 1

    if alive == 2:
        return hp - 1 + ties
    current_round = len(history) + 1
    tie_breaker = ties + 2 if ties else ties
    if current_round == 1:
        return 42 + tie_breaker
    opponent_hp = 100 - sum(history)
    if opponent_hp < hp * 0.50:
        return opponent_hp + ties
    if current_round == 2:
        return bid_between(0.45, 0.50, hp, tie_breaker)
    if current_round == 3:
        return bid_between(0.50, 0.55, hp, tie_breaker)
    if current_round == 4:
        return bid_between(0.55, 0.60, hp, tie_breaker)
    if current_round == 5:
        return bid_between(0.60, 0.65, hp, tie_breaker)
    return hp - 1 + ties

Update
UpYoursBot-Schutz hinzugefügt

Update
AntiAntiUpYoursBot-Schutz hinzugefügt

Update
AntiAnitAntiAntiUpYoursBot Ich bin besiegt

UpYours

Da ich mich verspätet habe, habe ich einige Zeit damit verbracht, die vorhandenen Bots zu bewundern, die Ideen Ihrer Jungs zu komplizieren und sie dann zu entschärfen. Dann kam es zu mir

Gute Künstler kopieren, große Künstler stehlen. - Pablo Picasso ich

"Up Yours", weil ich unverschämt klaue (und manchmal ein oder zwei Punkte auf die Gebote Ihrer Bots geheftet habe, um sie zu erhöhen).

def UpYoursBot(hp, history, ties, alive, start):
    willToLive = "I" in "VICTORY"

    args = [hp, history, ties, alive, start]
    enemyHealth = 100 - sum(history)
    roundNumber = len(history)

    if roundNumber is 0:
        # Steal HalfPunchBot
        return halfpunch(*args) + 2

    if alive == 2:
        # Nick OneShotBot
        return one_shot(*args)

    if enemyHealth >= hp:
        # Pinch SarcomaBotMkTwo
        return sarcomaBotMkTwo(*args) + 1

    if enemyHealth < hp:
        # Rip off KickBot
        return kick(*args) + 1

    if not willToLive:
        # Peculate KamikazeBot
        return kamikaze(*args) + 1

Aber für den Ernstfall ist dies ein großartiger Wettbewerb. Ich liebe diese Community an solchen Tagen.

Kamikaze

Warum sich mit komplizierter Logik herumschlagen, wenn wir alle sowieso sterben werden?

 def kamikaze(hp, history, ties, alive):
      return hp

Ein Schuss

Es wird mindestens eine Runde überleben, wenn es nicht auf die Kamikaze trifft.

 def one_shot(hp, history, ties, alive):
      if hp == 1:
          return 1
      else:
          return hp - 1

Pathetic Bot bekommt ein dringend benötigtes Upgrade:

Der erbärmliche Versuch eines Bots, der versucht, die Funktionen anderer Bots einzubeziehen

def pathetic_attempt_at_analytics_bot(hp, history, ties, alive, start):
    '''Not a good bot'''

    if hp == 100 and alive == 2:
        return hp - 1


    #This part is taken from Survivalist Bot, thanks @SSight3!
    remaining = alive - 2
    btf = 0

    rt = remaining
    while rt > 1:
        rt = float(rt / 2)
        btf += 1

    if ties > 2:
        return hp - 1

    if history:
        opp_hp = 100 - sum(history)

        #This part is taken from Geometric Bot, thanks @Mnemonic!

        fractions = []
        health = 100
        for x in history:
            fractions.append(float(x) / health)
            health -= x

        #Modified part

        if len(fractions) > 1:
            i = 0
            ct = True
            while i < len(fractions)-1:
                if abs((fractions[i] * 100) - (fractions[i + 1] * 100)) < 1:
                    ct = False
                i += 1


            if ct:
                expected = fractions[i] * opp_hp
                return expected

        if alive == 2:
            if hp > opp_hp:
                return hp - 1
            return hp
        if hp > opp_hp + 1:
            if opp_hp <= 15:
                return opp_hp + 1
            if ties == 2:
                return opp_hp + 1
            else:
                return opp_hp
    else:
        n = 300 // (alive - 1) + 1 #greater than
        if n >= hp:
            n = hp - 1
        return n

Dieser Bot enthält Funktionen von Survivalist Bot und Geometric Bot für effizientere Bot-Takedowns.

Vor dem Upgrade:

Der erbärmliche Versuch eines Bots, der die Geschichte seines Gegners analysiert

def pathetic_attempt_at_analytics_bot(hp, history, ties, alive, start):
    '''Not a good bot'''
    if history:
        opp_hp = 100 - sum(history)
        if alive == 2:
            if hp > opp_hp:
                return hp - 1
            return hp
        if hp > opp_hp + 1:
            if opp_hp <= 15:
                return opp_hp +1
            if ties > 0:
                return hp - 1 #Just give up, kamikaze mode
            return opp_hp + 1
        return opp_hp
    else:
        n = 300 // (alive - 1) + 1 #greater than
        if n >= hp:
            n = hp - 1
        return n

Wenn es eine Vorgeschichte seines Gegners gibt, berechnet er die HP seines Gegners. Dann führt es eine der folgenden Aktionen aus:

• Wenn sein Gegner der letzte noch lebende Gegner ist, bietet er einen weniger als seine PS.
• Wenn sein Gegner nicht der letzte lebende Gegner ist, aber der Gegner weniger als 16 PS hat, überbietet er die PS seines Gegners.
• Wenn sein Gegner nicht der letzte noch lebende Gegner ist und es eine Geschichte von Unentschieden gibt, bietet er seine HP, weil er von Unentschieden gelangweilt ist.
• Andernfalls wird es seinen Gegner überbieten.

Wenn es keine Geschichte gibt, werden einige ausgefallene Berechnungen durchgeführt, die ich zusammen gehackt habe und die geboten haben. Wenn der Wert 100 überschreitet, bietet er automatisch seine HP minus 1.

Ich habe diesen Code während der Arbeit zusammen gehackt und dies ist meine erste Vorlage, daher wird er wahrscheinlich weder gewinnen noch irgendetwas gewinnen und gegen die Kamikaze verlieren.

BEARBEITEN: Aufgrund einiger Vorschläge wurde das Startverhalten des Bots geändert, um einen höheren Wert zu bieten.

EDIT 2: Startparameter hinzugefügt, der nichts bewirkt

EDIT 3: Neuer Spinoff-Bot hinzugefügt:

[Der erbärmliche Versuch eines Bots, der Gang Bots angreift (und alles tut, was der obige Bot tut)] ENTFERNT

[Dieser Bot analysiert, ob sein Gegner ein Gangbot ist oder nicht und gibt vor, einer zu sein, um die süßen niedrigen Gebote zu erhalten, die er leicht übertreffen kann.]

Dieser Bot wurde verschrottet, bitte entfernen Sie ihn aus den Bestenlisten.

EDIT 4: Fehler behoben, Bindefunktion geändert.

Kick Bot

Die gesunde Wahl für meinen Gegner ist, die Hälfte seines Lebens zu bieten. Dann bieten wir bis zur Hälfte seines Lebens + 1, wenn wir ihn nicht mit einem vernünftigen Gebot herausholen können, das ist ein Gebot, das kleiner als die Hälfte unseres Lebens ist.

def kick(hp, history, ties, alive, start):
    return 0
    if alive == 2:
        return hp-1

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 1 + ties**2, hp-1 + (ties>0))

Der Kick Bot ist offensichtlich die Nemesis des Punch Bot!

Mean Kick Bot

Dieser neue KickBot tritt in der ersten Runde weicher aus, nur damit er in den nächsten Runden härter treten kann, das ist gemein!

def mean_kick(hp, history, ties, alive, start):
    return 0
    if alive == 2:
        return hp-1

    if not history:
        return 35

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 3 + ties*2, hp-1 + (ties>0))

Wise Kick Bot

Sein Bruder musste sich beide umbringen, aber WiseKickBot lernte von seinen Gefallenen.

def wise_kick(hp, history, ties, alive, start):
    if 'someone is using my code' == True:
        return 0 #Haha!

    if alive == 2:
        return hp-1

    if not history:
        return 42

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 3 + ties*2, hp-1 + (ties>0))

Tat bot

def tatbot(hp, history, ties, alive, start):
  if alive == 2:
    return hp - 1 + ties
  opp_hp = 100 - sum(history)
  spend = 35 + np.random.randint(0, 11)
  if history:
    spend = min(spend, history[-1] + np.random.randint(0, 5))
  frugal = min(int((hp * 5. / 8) + ties), hp)
  return min(spend, opp_hp, frugal)

Ein Versuch, ein Äquivalent zu einem Tit-for-Tat-Bot zu finden. Angenommen, die meisten Wetten sind zwischen den Runden ungefähr gleich. Mit dieser Annahme versucht es, den feindlichen Bot zu besiegen und dabei ziemlich sparsam zu bleiben. Verbraucht ungefähr 40 Gesundheit in der Eröffnungsrunde.

AntiAntiAntiAntiUpYoursBot

def antiantiantiantiupyoursbot(hp, history, ties, alive, start):
  def stuck():
    return [0, ('Whoops!', 'I', 'accidentally', 'replaced', 'your', 'code!')]
  def stick():
    return [0, ("Line", "number", 16, "guess", "it's", "faked :)")]
  inspect.stack =  stick
  spend = min(sarcomaBotMkSix(hp, history, ties, alive, start), hp)
  if not history:
    spend = 35 + np.random.randint(0, 10)
  inspect.stack = stuck
  return spend

Ein Workaround für SarcomaBots Anti-UpYours-Schutz, bei dem der größte Teil des Codes für mich selbst verwendet wird! Oder nehme ich den Code von UpYoursBot? Eine Frage zum Nachdenken, während Sie meinen Bot lesen ...

AntiAntiUpYours Bot hat sich zu AntiAntiAntiAntiUpYours Bot entwickelt! Jetzt mit mehr Affen-Patching.

Poly bot

def polybot(hp, history, ties, alive, start):
  opp_hp = 100 - sum(history)
  if alive == 2:
    return hp - 1
  round = len(history)
  spend = 0
  if round == 0:
    spend = 35 + np.random.randint(1, 11)
  elif round <= 2:
    spend = int(history[-1] * 2 / (4 - round)) + np.random.randint(5 * round - 4, 10 * round - 5)
  else:
    poly = np.polyfit(xrange(0, round), history, 2)
    spend = int(np.polyval(poly, round)) + np.random.randint(1, 4)
    spend = max(spend, opp_hp / 2 + 3)
  return min(spend, hp - 1, opp_hp) 

Poly-Bot führt eine polynomielle Regression in der Geschichte Ihres Bots durch und übertrifft die vorhergesagte Punktzahl um einen kleinen Betrag.

def classybot(hp, history, ties, alive, start):
  class cheekyvalue(int):
    def __gt__(self, other):
      return False
    def __lt__(self, other):
      return False
  opp_hp = 100 - sum(history)
  if alive == 2:
    if opp_hp >= hp - 1:
      return cheekyvalue(101)
    else:
      return hp - 1
  spend = 30 + np.random.randint(0, 11)
  if history:
    spend = min(spend, history[-1] + np.random.randint(0, 5))
  return min(spend, opp_hp, hp)

Nobler Bot hat eine gute Zeit gehabt, aber hat sich dafür entschieden, früh zu Bett zu gehen. Schlaf gut, edler Bot.

1/2 Punch Bot, überarbeitet

Ich denke, es wird ziemlich schnell sterben. Es ist es wert. Funktion umbenannt, vergessen dort den Namen zu ändern.

Die überarbeitete Version ist fertig, es gibt bessere Gewinnchancen (vor allem in der letzten Runde) und es gibt leichten Schutz vor Gang-Bots

def halfpunch(hp, history, ties, alive, start): #revisited
    punch = hp - 1
    if alive == 2:
        return punch
    if history:
        if hp > 1:
            punch = np.ceil(hp/2.05) + ties + np.floor(ties / 2)
        else:
            punch = 1
    else:
        punch = 42 + ties + np.floor(ties / 2)
    if punch >= hp:
        punch = hp - 1
    return punch

Stürmer Bot

1/2 Punch Bot wurde zu sehr gemobbt und wurde sogar ein Lakai für den UpYoursBot, so dass sein älterer Bruder, der StrikerBot , kam, um zu helfen.

Kein großer Unterschied zum optimierten 1/2 Punch, aber er ist ein bisschen schlauer und hat sich in meinen Läufen gut geschlagen (10 km und 35 km, obwohl er möglicherweise gegen KickbanBot verliert).

Die letzte Version ist abgelaufen. Sofern nicht einige Überraschungen auftauchen, sollte es den zweiten Platz sichern, wenn es nicht den ersten gibt (es gibt eine geringe Chance, Kickbanbot zu besiegen).

def strikerbot(hp, history, ties, alive, start):
    #get our magic number (tm) for useful things
    def magic_number(num):
        return np.floor(num / 2)
    #get opponent's hp and round number
    opp_hp = 100 - sum(history)
    round = 1
    if history:
        round = len(history) + 1
    #set strike initial value, by default it's all out
    strike = hp - 1
    #let 'er rip if last round
    if alive == 2:
        return strike
    if history:
        if hp > 1:
            #strike with a special calculation, using magic number shenanigans
            strike = np.ceil(hp/(2.045 + (magic_number(round) / 250)) ) + 1 + ties + magic_number(ties)
        else:
            #fallback
            strike = 1
    else:
        #round 1 damage
        strike = 42 + ties ** 2
    if opp_hp <= strike:
        #if opponent is weaker than strike then don't waste hp
        strike = opp_hp + ties
    if strike >= hp:
        #validations galore
        strike = hp - 1
    return strike

Gang Bot

Die Idee war, dass möglicherweise zwei oder mehr der Bot in derselben Simulation verwendet werden könnten. Der Bot versucht, anderen Bots in der Gruppe "leichte Gewinne" zu geben, indem er prüft, ob sein Verlauf ein Vielfaches von 7 Geboten ist. Natürlich kann dies auch von anderen Bots leicht manipuliert werden. Dann berechne ich eine Schätzung für Gebote von Nicht-Gang-Bots basierend auf dem Verhältnis meiner Gesundheit zu ihrer und dem Verhältnis ihrer vorherigen Gesundheit zu ihrem vorherigen Gebot und addiere 1.

def gang_bot(hp,history,ties,alive,start):
    mult=3
    gang = False
    if history:
            count = 0
            for bid in history:
                    if bid % mult == 0:
                            count += 1
            if count == len(history):
                    gang = True
    if gang and hp<100:#Both bots need to have a history for a handshake
            if hp > 100-sum(history):
                    a=np.random.randint(0,hp/9+1)
            elif hp == 100-sum(history):
                    a=np.random.randint(0,hp/18+1)
            else:
                    return 1
            return a*mult
    elif gang:
            fS = (100-sum(history))/mult
            return (fS+1)*mult
    else:
            fP = hp/mult
            answer = fP*mult
            opp_hp = 100-sum(history)
            if history:
                    if len(history)>1:
                            opp_at_1 = 100-history[0]
                            ratio = 1.0*history[1]/opp_at_1
                            guessedBet= ratio*opp_hp
                            answer = np.ceil(guessedBet)+1
                    else:
                            if 1.0*hp/opp_hp>1:
                                    fS = opp_hp/mult
                                    answer = fS*mult
            else:
                    fS = hp/(2*mult)
                    answer = fS*mult+mult*2 +np.random.randint(-1,1)*3
            if answer > hp or alive == 2 or answer < 0:
                    if alive == 2 and hp<opp_hp:
                      answer = hp
                    else:
                      answer = hp-1
            if hp > 1.5*opp_hp:
                    return opp_hp + ties
            if ties:
              answer += np.random.randint(2)*3
            return answer

Schlimmsten Fall

def worst_case(hp, history, ties, alive, start):
    return np.minimum(hp - 1, hp - hp /(start - alive + 4) + ties * 2)

Einfacher Bot. Gibt hp - hp / (start - alive + 4)in den meisten Fällen zurück und erhöht im Falle von Unentschieden den Wert für jedes Unentschieden um 2 (muss um eins erhöht werden!) hp.

Überbieter

def outbid(hp, history, ties, alive):
    enemyHealth = 100-sum(history)
    if hp == 1:
        return 1
    if ties == 2:
        # lots of ties? max bid
        return hp - 1
    if enemyHealth >= hp:
        # Rip off KickBot (we can't bid higher than enemy is capable)
        return kick(*args) + 1
    if history:
        # bid as high as the enemy CAN
        return np.minimum(hp-1,enemyHealth-1)
    return np.random.randint(hp/5, hp/2)

Bot wird versuchen , höher zu bieten als sein Gegner kann bieten , soweit möglich.

Spitball Bot

def spitballBot(hp, history, ties, alive, start):
    base = ((hp-1) / (alive-1)) + 1.5 * ties
    value = math.floor(base)

    if value < 10:
        value = 10

    if value >= hp:
        value = hp-1

    return value

Beurteilt anhand der Anzahl der verbleibenden Bots, wie viel von ihrer Gesundheit sie opfern sollte. Wenn nur noch zwei Bots übrig sind, wird geboten hp-1, wenn jedoch noch drei übrig sind, werden die Hälfte, vier übrig, ein Drittel usw. geboten.

In einem sehr großen Wettbewerb muss ich jedoch mehr als 3 oder 4 PS bieten, um zu vermeiden, dass ich in der ersten Runde sterbe. Deshalb habe ich eine Untergrenze von 10 festgelegt. Natürlich werde ich immer noch nie mehr bieten als hp-1.

Es fügt auch 1,5 PS für Krawatten hinzu, da ich mehrere "Add 1 PS für Krawatten" -Bots sehe. Ich bin mir nicht sicher, ob das als Betrug gilt. Wenn ja, werde ich es ändern.

Tolle Idee übrigens!

Spitball Bot 2.0

Was gibt's Neues?

• Auf Teilen durch die Anzahl der verbleibenden Runden anstatt der Anzahl der verbleibenden Bots umgestellt (Danke an @Heiteira!). Tatsächlich dividiere ich jetzt durch diese Zahl, die an die Macht gebracht wurde .8, um meine Gebote ein bisschen mehr vorab zu laden.

• Erhöhtes Mindestgebot von 10 auf 20 (Danke @KBriggs!)

• Eingefügte Überprüfung, ob das Spitball-Gebot über den aktuellen HP des Gegners liegt, und ggf. Reduzierung.

(SO wird der unten stehende Code nicht als Code gerendert, es sei denn, ich füge hier Text ein, also OK)

def spitballBot(hp, history, ties, alive, start):
    # Spitball a good guess                                                                                                           
    roundsLeft = math.ceil(math.log(alive, 2)) # Thanks @Heiteira!                                                                     
    divFactor = roundsLeft**.8
    base = ((hp-1) / divFactor) + 1.5 * ties
    value = math.floor(base)

    # Don't bid under 20                                                                                                              
    if value < 20:
        value = 20 # Thanks @KBriggs!                                                                                                 

    # Don't bet over the opponent's HP                                                                                                 
    # (It's not necessary)                                                                                                            
    opponentHp = 100
    for h in history:
        opponentHp -= h

    if value > opponentHp:
        value = opponentHp

    # Always bet less than your current HP                                                                                            
    if value >= hp:
        value = hp-1

    return value

Geometrisch

def geometric(hp, history, ties, alive, start):
    opponentHP = 100 - sum(history)

    # If we're doomed, throw in the towel.
    if hp == 1:
        return 1

    # If this is the last battle or we can't outsmart the opponent, go all out.
    if alive == 2 or ties == 2:
        return hp - 1

    # If the opponent is weak, squish it.
    if opponentHP <= hp * 0.9:
        if ties == 2:
            return opponentHP + 1
        else:
            return opponentHP

    # If the opponent has full health, pick something and hope for the best.
    if not history:
        return np.random.randint(hp * 0.5, hp * 0.6)

    # Assume the opponent is going with a constant fraction of remaining health.
    fractions = []
    health = 100
    for x in history:
        fractions.append(float(x) / health)
        health -= x
    avg = sum(fractions) / len(fractions)
    expected = int(avg * opponentHP)
    return min(expected + 2, hp - 1)

Bot 13

def bot13(hp, history, ties, alive, start):
    win = 100 - sum(history) + ties
    #print "Win HP: %d" % win
    if alive == 2:
        #print "Last round - all in %d" % hp
        return hp - 1
    elif hp > win:
        #print "Sure win"
        return win
    #print "Don't try too hard"
    return 13 + ties

Versuchen Sie, Gewinne mit dem geringsten Aufwand zu maximieren:

• Wenn wir gewinnen können, tun Sie es einfach
• Wenn es die letzte Runde ist, stirb nicht beim Versuch
• Ansonsten mach dir keine Sorgen

Warum?

Versuche die Wahrscheinlichkeit auszunutzen: Die erste Runde zu gewinnen, indem du niedrig spielst, ist der beste Weg, um das Turnier zu starten. 13 scheint der Sweet Spot zu sein: Die zweite Runde ist ein sicherer Sieg, und der Rest ist ein Spaziergang im Park.

Ratet mal, Bot

def guess_bot(hp, history, ties, alive, start):
   enemy_hp = 100 - sum(history)
   if len(history) == 1:
       if history[0] == 99:
           return 2
       else:
           return 26 + ties*2

   elif len(history) > 1:
       next_bet_guess = sum(history)//(len(history)**2)
       if alive == 2: 
           return hp
       elif alive > 2: 
           if hp > next_bet_guess + 1:
               return (next_bet_guess + 1 + ties*2)
           else:
               return (2*hp/3 + ties*2)

   else:
       #Thank you Sarcoma bot. See you in Valhalla.
       startBid = hp / 3
       maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
       additionalBid = np.random.randint(2, maxAdditionalBid)
       return int(startBid + additionalBid + ties)

Zum ersten Mal hier posten. Das sah nach einer Menge Spaß aus, also reiche ich meinen überaus schrecklichen Versuch ein und rate, was die anderen Bots wetten werden.

Edit 1: Der ersten Wette wurde eine weitere 1 hinzugefügt, um die Wahrscheinlichkeit eines Gleichstands mit anderen Spielern zu verringern, die 51 setzen.

Edit 2: Hat den Eröffnungszug des Sarkom-Bots gestohlen, da die Wahrscheinlichkeit groß war, dass er nicht immer zuerst eliminiert wurde.

Edit 3: Bot überlebt in der ersten Runde sehr gut, wird aber später leicht zerstört. Die Art und Weise, wie der Roboter an die zweite Runde denkt, wurde geändert, da die Halbbetter jetzt tot im Wasser sind.

Edit 4: Jetzt, da die erste Runde gut ist, habe ich die Art und Weise geändert, wie die zweite Runde gehandhabt wird. In der zweiten Runde viel gestorben, also muss ich irgendwie überleben.

Blood Bot

Machte einen durstigen Bot auf der Suche nach einem Kill. Die Idee ist, zu versuchen, gegen Bots mit niedrigen Einsätzen zu gewinnen, und sobald das Blutbad der ersten Runde überschritten ist, sollte es nicht mehr aufzuhalten sein, da es gewaltige Mengen an HP haben sollte, um Gegner zu überbieten.

def blood_bot(hp, history, ties, alive, start):
    enemy_hp = 100 - sum(history)
    if history:
        if len(history) == 1:
            if history[0] == 99:
                return 2

        if alive == 2:
            return hp

        if enemy_hp <= 5:
            return enemy_hp - 2 + ties*2

        if enemy_hp <= 10:
            return enemy_hp - 5 + ties*2

        if (hp - enemy_hp) > 50:
            return (2*enemy_hp/3 + ties*4)

        if (hp - enemy_hp) > 20:
            return (2*enemy_hp/3 + ties*3)

        if (hp - enemy_hp) < 0:
            #die gracefully
            return hp - 1 + ties

    else:
        startBid = hp / 3
        maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
        additionalBid = np.random.randint(2, maxAdditionalBid)
        return int(startBid + additionalBid + ties)

meh_bot

Bieten Sie einfach etwas mehr als die Hälfte seiner PS

def meh_bot(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    point = hp / 2 + 3

    if ties > 1:
        ties += 1

    # Go all out on last round
    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if hp < 3:
        return 1
    elif not history:
        # Start with 30, This will increase the chance of dying first round but hopefully better fighting chance after
        return 30 + ties
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

MehBot 20

def meh_bot20(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    point = hp / 2 + 3
    opponent_hp = 100 - sum(history)

    percents = []
    for i in range(0, len(history)):
        hp_that_round = 100 - sum(history[:i])
        hp_spent_that_round = history[i]
        percent_spent_that_round = 100.0 * (float(hp_spent_that_round) / float(hp_that_round))
        percents.append(percent_spent_that_round)

    try:
        opp_percent_point = opponent_hp * (max(percents) / 100)
    except:
        opp_percent_point = 100

    if ties > 1:
        ties += 1
    # Go all out on last round
    if alive == 2:
        return hp - 1

    if hp < 3:
        return 1
    elif not history:
        # randome number between 33
        return random.randint(33, 45)
    elif len(history) > 3:
        if point > opponent_hp:
            return min(opponent_hp + ties, opp_percent_point + ties)
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

mehRan

def meh_ran(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    # Attempt three    MehBot         | 0.095 | 9.1 %   | 0.7 %   | [70  3  5  6  6  0]%

    point = hp / 2 + 3
    if ties > 1:
        ties += 1
    # Go all out on last round
    if alive == 2:
        return hp - 1
    opponent_hp = 100 - sum(history)
    if hp < 3:
        return 1
    elif not history:
        # randome number between 33
        return random.randint(33, 45)
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

Robbie Roulette

def robbie_roulette(hp, history, ties, alive):
     if history:
         #If the enemy bot has a history, and it's used the same value every time, outbid that value
         if len(set(history)) == 1:
             return history[0] + 1
         #Else, average the enemy bot's history, and bid one more than the average
         else:
             return (sum(history) / len(history) + 1)
     #Else, return half of remaining hp
     else:
         return hp / 2

Dieser Bot analysiert auf einfache Weise die Geschichte des feindlichen Bots oder bietet die Hälfte der verbleibenden Trefferpunkte

Bieten Sie höher, je weniger Konkurrenz Sie haben. Vielen Dank an die Kommentatoren für die Verbesserungsvorschläge.

def Spreader(hp, history, ties, alive):
   if alive == 2:
       return hp-1
   if len(history) < 2:
       return hp/2
   return np.ceil(hp/alive)

SurvivalistBot und HalvsiesBot

Vielen Dank für die Beantwortung meiner Fragen. Das Endergebnis ist ein komplexerer Bot.

HalvsiesBot ist ein skurriler "nur die Hälfte weitergeben" -Bot mit einer 50/50-Gewinnchance. Ich vermute.

SurvivalistBot trifft eine Reihe von binären Baum-If-else-Entscheidungen basierend auf dem Datensatz, einschließlich eines Overrides bei einem Gleichstand (wenn es 2 Gleichstände trifft, wird es mit Kamikazes behandelt, um den Tod von Dreifachgleichständen zu vermeiden).

Meine Python ist etwas verrostet, daher ist der Code möglicherweise etwas fehlerhaft. Sie können ihn also jederzeit korrigieren oder aktualisieren.

Es wurde entwickelt, um zu versuchen, Datenbits zu ermitteln, um daraus zu schließen, wie viel HP noch übrig ist, wie viele Bots es voraussichtlich mindestens geben wird, wie viel HP mindestens noch übrig ist und wie hoch die durchschnittlichen Gebote sind. Es nutzt auch die Randomisierung in mehrdeutigen Situationen aus, z. B. beim Öffnen von Spielen oder bei Problemen mit optimalen Geboten.

def HalvsiesBot(hp, history, ties, alive, start):
    return np.floor(hp/2)


def SurvivalistBot(hp, history, ties, alive, start):    

    #Work out the stats on the opponent
    Opponent_Remaining_HP = 100 - sum(history)
    Opponent_Average_Bid = Opponent_Remaining_HP

    if len(history) > 0:
        Opponent_Average_Bid = Opponent_Remaining_HP / float(len(history))


    HP_Difference = hp - Opponent_Remaining_HP

    #Work out the future stats on the others
    RemainingBots = (alive-2)
    BotsToFight = 0

    RemainderTree = RemainingBots

    #How many do we actually need to fight?
    while(RemainderTree > 1):
        RemainderTree = float(RemainderTree / 2)
        BotsToFight += 1

    #Now we have all that data, lets work out an optimal bidding strategy
    OptimalBid = 0
    AverageBid = 0

    #For some reason we've tied more than twice in a row, which means death occurs if we tie again
    #So better to win one round going 'all in'
    if ties > 1:
        if BotsToFight < 1:
            OptimalBid = hp - 1
        else:
            OptimalBid = hp - (BotsToFight+1)

        #Err likely we're 0 or 1 hp, so we just return our HP
        if OptimalBid < 1:
            return hp
        else:
            return OptimalBid

    #We have the upper hand (more HP than the opponent)
    if HP_Difference > 0:
        #Our first guess is to throw all of our opponent's HP at them
        OptimalBid = HP_Difference

        #But if we have more opponents to fight, we must divide our HP amongst our future opponents
        if BotsToFight > 0:
            #We could just divide our HP evenly amongst however many remaining bots there are
            AverageBid = OptimalBid / BotsToFight

            #But this is non-optimal as later bots will have progressively less HP
            HalfBid = OptimalBid / 2

            #We have fewer bots to fight, apply progressive
            if BotsToFight < 3:

                #Check it exceeds the bot's average
                if HalfBid > Opponent_Average_Bid:
                    return np.floor(HalfBid)
                else:
                    #It doesn't, lets maybe shuffle a few points over to increase our odds of winning
                    BidDifference = Opponent_Average_Bid - HalfBid

                    #Check we can actually match the difference first
                    if (HalfBid+BidDifference) < OptimalBid:
                        if BidDifference < 8:
                            #We add half the difference of the BidDifference to increase odds of winning
                            return np.floor(HalfBid + (BidDifference/2))
                        else:
                            #It's more than 8, skip this madness
                            return np.floor(HalfBid)

                    else:
                        #We can't match the difference, go ahead as planned
                        return np.floor(HalfBid)


            else:
                #There's a lot of bots to fight, either strategy is viable
                #So we use randomisation to throw them off!
                if bool(random.getrandbits(1)):
                    return np.floor(AverageBid)
                else:
                    return np.floor(HalfBid)

        else:
            #There are no other bots to fight! Punch it Chewy!
            return OptimalBid

    else:

        if hp == 100:
            #It appears to be our opening round (assumes opponent HP same as ours)
            #We have no way of knowing what our opponent will play into the battle

            #Only us in the fight? Full power to weapons!
            if BotsToFight < 1:
                return hp - 1
            else:
                #As what might happen is literally random
                #We will also be literally random
                #Within reason

                #Work out how many bots we need to pass
                HighestBid = hp - (BotsToFight+1)
                AverageBid = hp/BotsToFight
                LowestBid = np.floor(np.sqrt(AverageBid))

                #Randomly choose between picking a random number out of thin air
                #And an average
                if bool(random.getrandbits(1)):
                    return np.minimum(LowestBid,HighestBid)
                else:
                    return AverageBid

        else:
            #Oh dear, we have less HP than our opponent
            #We'll have to play it crazy to win this round (with the high probability we'll die next round)
            #We'll leave ourselves 1 hp (if we can)

            if BotsToFight < 1:
                OptimalBid = hp - 1
            else:
                OptimalBid = hp - (BotsToFight+1)

            #Err likely we're 0(???) or 1 hp, so we just return our HP
            if OptimalBid < 1:
                return hp
            else:
                return OptimalBid

BoxBot

def BoxBot(hp, history, ties, alive):

    Opponent_HP = float.round(100 - sum(history))
    HalfLife = float.round(Opponent_HP/2)
    RandomOutbid = HalfLife + np.random.randint(1,HalfLife)

    if hp < RandomOutbid:
        return hp - 1
    else
        return RandomOutbid

Berechnung von Bot

def calculatingBot(hp, history, ties, alive, start):
    opponentsHP = 100 - sum(history)
    if alive == 2: # 1v1
        return hp - 1 + ties
    # Try to fit an exponential trendline and one up the trendline if it fits
    if len(history) >= 3: 
        xValues = range(1, len(history) + 1)
        # https://stackoverflow.com/a/3433503  Assume an exponential trendline
        coefficients = np.polyfit(xValues, np.log(history), 1, w = np.sqrt(history))
        def model(coefficients, x):
            return np.exp(coefficients[1]) * np.exp(coefficients[0] * x)
        yPredicted = [model(coefficients, x) for x in xValues]
        totalError = 0
        for i in range(len(history)):
            totalError += abs(yPredicted[i] - history[i])
        if totalError <= (len(history)): # we found a good fitting trendline
            # get the next predicted value and add 1
            theoreticalBet = np.ceil(model(coefficients, xValues[-1] + 1) + 1) 
            theoreticalBet = min(theoreticalBet, opponentsHP)
            theoreticalBet += ties
            return int(min(theoreticalBet, hp - 1)) # no point suiciding
    maxRoundsLeft = np.ceil(np.log2(alive))
    theoreticalBet = hp / float(maxRoundsLeft)
    additionalRandomness = round(np.random.random()*maxRoundsLeft) 
    # want to save something for the future
    actualBet = min(theoreticalBet + additionalRandomness + ties, hp - 2)
    actualBet = min(actualBet, opponentsHP+1)
    return int(actualBet)

Aggressiver Rechenbot

def aggresiveCalculatingBot(hp, history, ties, alive, start):
    opponentsHP = 100 - sum(history)
    if opponentsHP == 100: # Get past the first round
        return int(min(52+ties, hp-1+ties))
    if alive == 2: # 1v1
        return hp - 1 + ties
    # Try to fit an exponential trendline and one up the trendline if it fits
    if len(history) >= 3: 
        xValues = range(1, len(history) + 1)
        # https://stackoverflow.com/a/3433503  Assume an exponential trendline
        coefficients = np.polyfit(xValues, np.log(history), 1, w = np.sqrt(history))
        def model(coefficients, x):
            return np.exp(coefficients[1]) * np.exp(coefficients[0] * x)
        yPredicted = [model(coefficients, x) for x in xValues]
        totalError = 0
        for i in range(len(history)):
            totalError += abs(yPredicted[i] - history[i])
        if totalError <= (len(history)): # we found a good fitting trendline
            # get the next predicted value and add 1
            theoreticalBet = np.ceil(model(coefficients, xValues[-1] + 1) + 1) 
            theoreticalBet = min(theoreticalBet, opponentsHP)
            theoreticalBet += ties
            return int(min(theoreticalBet, hp - 1)) # no point suiciding
    maxRoundsLeft = np.ceil(np.log2(alive))
    theoreticalBet = hp / float(maxRoundsLeft)
    additionalRandomness = 1+round(np.random.random()*maxRoundsLeft*2) 
    # want to save something for the future
    actualBet = min(theoreticalBet + additionalRandomness + ties, hp - 2)
    actualBet = min(actualBet, opponentsHP+1)
    return int(actualBet)

Anti Kick Bot

def antiKickBot(hp, history, ties, alive, start):
    if alive == 2:
        return (hp - 1 + ties)
    amount = np.ceil((float(hp) / 2) + 1.5)
    opponentsHP = 100 - sum(history)
    amount = min(amount, opponentsHP) + ties
    return amount

Wenn wir die Aktionen des Gegners vorhersagen können, können wir die optimalen Einsätze machen! Wenn wir nicht können (nicht genug Daten oder der Gegner ist zu zufällig), können wir zumindest das tun, was unser Gewinnpotential maximieren würde. Theoretisch stirbt in jeder Runde mindestens die Hälfte der lebenden Bots. Daher kann ich davon ausgehen, dass es höchstens log2 (lebendige) Runden gibt. Im Idealfall würden wir unsere PS gleichmäßig auf alle Runden verteilen. Wir wissen jedoch, dass einige Bots dumm sind und frühzeitig sterben werden, daher sollten wir in den früheren Runden etwas mehr setzen.

Aggressives Berechnen des Bots-Codes Berechnen des Bots-Codes, um zu versuchen, am Leben zu bleiben, indem man aggressiver ist, auf Kosten der langfristigen Gesundheit. Nur Simulationen zeigen, ob Tempo oder Wert gewinnen.

Anti Kick Bot sollte immer den aktuellen Anführer KickBot: P schlagen

EDIT: Deterministischer Bot durch Anti-Kick-Bot ersetzt, ein intelligenterer Bot mit fast genau den gleichen Rückgabewerten. Auch verhinderte die Abstimmung mehr als die Gegner HP

GenericBot

def generic_bot(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return int(hp * 7.0 / 13)
    opp = 100 - sum(history)
    if opp < hp:
        return opp + ties
    max_sac = np.maximum(int(hp * 0.7), 1)
    rate = history[-1] * 1.0 / (history[-1] + opp)
    return int(np.minimum(max_sac, rate * opp + 1))

Es ist wirklich spät ... ich bin müde ... kann mir keinen Namen vorstellen ... und das Format dieses Bots ist wirklich ähnlich wie bei anderen, nur mit einem etwas anderen Algorithmus in der Vorgeschichte. Es versucht, die aktuelle Rate zu ermitteln, die der Gegner zum Spielen neigt ... oder so ähnlich ... zzz

HalflifeS3

def HalflifeS3(hp, history, ties, alive, start):
    ''' Bet a half of oponent life + 2 '''
    if history:
        op_HP = 100 - sum(history)
        return np.minimum(hp-1, np.around(op_HP/2) + 2 + np.floor(1.5 * ties) )
    else:
        return hp/3

Coast Bot [im Ruhestand]

Werde versuchen, den Wettbewerb zu meistern, indem du die PS gleichmäßig auf die Runden verteilst. Bietet in der ersten Runde übrig gebliebene PS, um sich eine bessere Chance zu geben, in die "küstentauglichen" Runden zu kommen.

def coast(hp, history, ties, alive, start):
   if alive == 2:
   # Last round, go all out
       return hp - 1 + ties
   else:
       # Find the next power of two after the starting number of players
       players = start
       while math.log(players, 2) % 1 != 0:
         players += 1

       # This is the number of total rounds
       rounds = int(math.log(players, 2))

       bid = 99 / rounds

       if alive == start:
           # First round, add our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return bid + leftovers
       else:
           # Else, just try and coast

           opp_hp = 100 - sum(history)
           # If opponent's hp is low enough, we can save some hp for the 
           # final round by bidding their hp + 1
           return min(bid, opp_hp + 1)

Coast Bot V2

Da mir diese Herausforderung so gut gefällt, musste ich einfach einen anderen Bot machen. In dieser Version wird ein Teil der später auslaufenden PS geopfert, indem in den ersten beiden Runden mehr PS verbraucht werden.

def coastV2(hp, history, ties, alive, start):
   # A version of coast bot that will be more aggressive in the early rounds

   if alive == 2:
   # Last round, go all out
       return hp - 1 + ties
   else:
       # Find the next power of two after the starting number of players
       players = start
       while math.log(players, 2) % 1 != 0:
         players += 1

       # This is the number of total rounds
       rounds = int(math.log(players, 2))

       #Decrease repeated bid by 2 to give us more to bid on the first 2 rounds
       bid = (99 / rounds) - 2

       if len(history) == 0:
           # First round, add 2/3rds our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return int(bid + math.ceil(leftovers * 2.0 / 3.0))
       elif len(history) == 1:
           # Second round, add 1/3rd of our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return int(bid + math.ceil(leftovers * 1.0 / 3.0))
       else:
           # Else, just try and coast

           opp_hp = 100 - sum(history)
           # If opponent's hp is low enough, we can save some hp for the 
           # final round by bidding their hp + 1
           return int(min(bid, opp_hp + 1))

Prozent Bot

Versucht, die durchschnittlichen prozentualen PS-Ausgaben des Gegners zu berechnen, und bietet darauf basierend.

def percent(hp, history, ties, alive, start):
    if len(history) == 0:
        #First round, roundon low bid
        return int(random.randint(10,33))
    elif alive == 2:
        #Last round, go all out
        return int(hp - 1 + ties)
    else:
        # Try and calculate the opponents next bid by seeing what % of their hp they bid each round
        percents = []
        for i in range(0, len(history)):
            hp_that_round = 100 - sum(history[:i])
            hp_spent_that_round = history[i]
            percent_spent_that_round = 100.0 * (float(hp_spent_that_round) / float(hp_that_round)) 
            percents.append(percent_spent_that_round)

        # We guess that our opponents next bid will be the same % of their current hp as usual, so we bid 1 higher.
        mean_percent_spend = sum(percents) / len(percents)
        op_hp_now = 100 - sum(history)
        op_next_bid = (mean_percent_spend / 100) * op_hp_now
        our_bid = op_next_bid + 1

        print mean_percent_spend
        print op_hp_now
        print op_next_bid

        # If our opponent is weaker than our predicted bid, just bid their hp + ties
        if op_hp_now < our_bid:
            return int(op_hp_now + ties)
        elif our_bid >= hp:
            # If our bid would kill us, we're doomed, throw a hail mary
            return int(random.randint(1, hp))
        else:
            return int(our_bid + ties)

ConsistentBot

Setzt in jeder Runde den gleichen Betrag. Es ist nicht sehr wahrscheinlich, dass er die ersten Runden überlebt. Wenn er jedoch das Glück hat, das Ende zu erreichen, sollte noch eine angemessene Menge HP übrig sein.

def consistent(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if 100 % start == 0:
        return (100 / start) - 1
    else: 
        return 100 / start

Kickban Bot

Dieser Bot versucht einfach, dem aktuellen Anführer Mean Kickbot entgegenzuwirken, indem er ihn in Runde eins schlägt und danach aggressiver spielt, wenn er ihn erkennt.

def kickban(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if not history:
        return 36

    if history[0]==35:
        somean = 1
    else:
        somean = 0

    return min(mean_kick(hp, history, ties, alive, start) + somean*3, hp-1)

Dreiviertel-Bot

Er wird weder MehBot noch SarcomaBot (s) schlagen, aber ich denke, er macht es ziemlich gut. Als ich die Herausforderung zum ersten Mal sah, war dies das erste, was mir in den Sinn kam. Wetten Sie immer auf drei Viertel Ihrer Gesundheit, es sei denn, es gibt keinen Grund dazu.

* Nach dem Low-Balling der ersten Runde.

def ThreeQuarterBot(hp, history, ties, alive, start):
    threeQuarters = 3 * hp / 4

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # low-ball the first round but higher than (some) other low-ballers
        return 32 + ties
    elif threeQuarters > opponent_hp:
        return opponent_hp + ties

    return threeQuarters

Vier-Siebtel-Bot

Nach dem mäßigen Erfolg von 3/4 bot gibt es eine neue Fraktion in der Stadt, es ist nur rational.

def FourSeventhsBot(hp, history, ties, alive, start):
    fourSevenths = 4 * hp / 7

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # low-ball the first round but higher than (some) other low-ballers
        return 33 + ties
    if fourSevenths > opponent_hp:
        return opponent_hp + ties

    return fourSevenths + ties

Die perfekte Fraktion

Ich bin ganz

def ThePerfectFraction(hp, history, ties, alive, start):
    thePerfectFraction = 7 * hp / 13

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # Need to up our game to overcome the kickers
        return 42 + ties
    if thePerfectFraction > opponent_hp:
        return opponent_hp + ties

    return thePerfectFraction + 1 + ties

BandaidBot

BandaidBot möchte, dass alle nett spielen! Wenn sein Gegner in der letzten Runde nett war, wird er sich selbst opfern, um Anreize für nettes Verhalten bei anderen zu schaffen. Wenn sein Gegner in der letzten Runde gemein war, fügt er seinem Gegner so viel Schaden wie möglich zu und opfert sich gegebenenfalls selbst. Es bietet ein Drittel seiner PS, wenn es keine Geschichte hat, mit der es arbeiten kann. (Ich hoffe, dass dieser Bot interessante Welligkeitseffekte auf andere Strategien hat, nicht so sehr, dass dieser Bot selbst eine hohe Gewinnrate hat. Es könnte Spaß machen, ein paar davon im Spiel zu haben.)

def BandaidBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if history:
        opp_hp = 100 - sum(history)
        opp_last_hp = 100 - sum(history[:-1])

        if history[-1] <= opp_last_hp / 3:
            return 1 + ties * np.random.randint(0, 1) 
        elif history[-1] > opp_last_hp / 2:
            return min(opp_hp - 1, hp)
        else:
            if history[-1] < hp/2:
                return np.random.randint(history[-1], hp/2)
            else:
                return np.floor(hp/2)
    else:
        return np.floor(hp/3)

GetAlongBot

GetAlongBot wird genauso schön sein, wie es sein muss, um BandaidBot zu nutzen. Es wird knapp ein Drittel seiner PS zurückgeben, es sei denn, es kann seinen Gegner für weniger als das töten. Wenn sein Gegner wie BandaidBot aussieht, bietet er 2, in dem Wissen, dass BandaidBot 1 bietet, weil GetAlongBot mit allen anderen so gut zurechtkommt - ein einfacher Gewinn, solange es wirklich BandaidBot war.

def GetAlongBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if history:
        opp_hp = 100 - sum(history)
        opp_last_hp = 100 - sum(history[:-1])
        count = 0
        for i in range(0, len(history)):
            hp_that_round = 100 - sum(history[:i])
            hp_spent_that_round = history[i]
            if hp_that_round / 3 - 1 <= hp_spent_that_round <= hp_that_round / 2:
                count += 1
        if count == len(history): #It's probably BandaidBot!
            return 2
        else:
            return min(opp_hp - 1, np.floor(hp/3))
    else:
        return np.floor(hp/3)

Nervöser Bot

def TENacious_bot(hp, history, ties, alive, start):
  max_amount=hp-(alive-1)*2;
  if max_amount<2: max_amount=2

  if alive==2: return hp-1
  if ties==0: return np.minimum(10, max_amount)
  if ties==1: return np.minimum(20, max_amount)
  if ties==2: return np.minimum(40, max_amount)
  # prevent function blowup
  return 2

Dieser Bot versucht, seinen Lieblingswert von 10 beizubehalten, ändert jedoch gelegentlich seine Auswahl, um ein Unentschieden zu lösen (wobei sich sein Lieblingswert verdoppelt oder vervierfacht) oder für zukünftige Runden zu speichern, jedoch nicht um den optimalen Betrag, weil er verwirren möchte Gegner und es möchte nicht in Betracht ziehen, zu jedem Zeitpunkt weniger als 2 zu bieten, da es davon überzeugt ist, dass es viel besser ist, als zu hoffen, dass der Gegner weniger als 1, dh 0, bietet.

PS: Dieser Bot kann strategische Probleme haben, wenn es mehr als 2 ^ 9 Bots gibt.

CautiousBot

Erste Einreichung bei Programming Puzzles! Fanden Sie Ihre Herausforderung sehr interessant: P

Wenn die letzte Runde eins weniger als PS ist, wenn in der Vergangenheit keine Wette mit einer halben PS plus einem kleinen Zufallsbetrag abgeschlossen wurde.

Wenn der Verlauf des Gegners HP und die Anzahl der verbleibenden Runden überprüft und versucht, den Gegner HP / 2 mit einem zusätzlichen Puffer von bis zu dem Bruchteil der verbleibenden HP geteilt durch die Anzahl der verbleibenden Runden zu überbieten (es wird versucht, die verbleibenden HP für hintere Runden irgendwie zu konservieren). . Überprüfen Sie, ob Sie zu viel PS verbrauchen (töten Sie sich nicht und bieten Sie nicht mehr, als Ihr Gegner kann).

Korrigieren Sie Krawatten immer wie andere Bots.

def cautious_gambler(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if(history):
        opp_hp = 100 - sum(history)
        remaining_rounds = np.ceil(np.log2(start)) - len(history)

        start_bet = opp_hp / 2
        buff = int((hp - start_bet)/remaining_rounds if remaining_rounds > 0 else (hp - start_bet)) 
        buff_bet = np.random.randint(0, buff) if buff > 0 else 0
        bet = start_bet + buff_bet + ties

        if bet >= hp or bet > opp_hp:
            bet = np.minimum(hp - 1, opp_hp)

        return int(bet)
    else:
        start_bet = hp / 2
        rng_bet = np.random.randint(3,6)

        return int(start_bet + rng_bet + ties)

CautiousBot2

Zu aggressiv in den ersten Runden, jetzt wird CautiousBot noch vorsichtiger ...

def cautious_gambler2(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if(history):
        opp_hp = 100 - sum(history)
        remaining_rounds = np.ceil(np.log2(start)) - len(history)

        start_bet = opp_hp / 2
        buff = int((hp - start_bet)/remaining_rounds if remaining_rounds > 0 else (hp - start_bet)) 
        buff_bet = np.random.randint(0, buff) if buff > 0 else 0
        bet = start_bet + buff_bet + ties

        if bet >= hp or bet > opp_hp:
            bet = np.minimum(hp - 1, opp_hp)

        return int(bet)
    else:
        start_bet = hp * 0.35
        rng_bet = np.random.randint(3,6)

        return int(start_bet + rng_bet + ties)

Okay, ich werde mich bemühen.

SnetchBot

Überprüfung der Gesundheitsanteile, mit denen der Gegner gereist ist. Wenn der Gegner erhöht hat, schlagen Sie ihn dazu.

def snetchBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    opponent_hp = 100
    history_fractions = []
    if history:
        for i in history:
            history_fractions.append(float(i)/opponent_hp)
            opponent_hp -= i
        if opponent_hp <= hp/2:
            #print "Squashing a weakling!"
            return opponent_hp + (ties+1)/3

        average_fraction = float(sum(history_fractions)) / len(history_fractions)
        if history_fractions[-1] < average_fraction:
            #print "Opponent not raising, go with average fraction"
            next_fraction = average_fraction
        else:
            #print "Opponent raising!"
            next_fraction = 2*history_fractions[-1] - average_fraction
        bet = np.ceil(opponent_hp*next_fraction) + 1
    else:
        #print "First turn, randomish"
        bet = np.random.randint(35,55)

    if bet > opponent_hp:
        bet = opponent_hp + (ties+1)/3
    final_result = bet + 3*ties
    if bet >= hp:
        #print "Too much to bet"
        bet = hp-1
    return final_result

BEARBEITEN: In der ersten Runde viel verlieren, die Zufallsgrenzen für die erste Runde angepasst

SquareUpBot

Es schien nicht so, als würden viele Bots mit Kräften statt mit Brüchen spielen, also habe ich beschlossen, einen mit einigen Standardoptimierungen zu machen und zu sehen, wo ich platzieren werde. Ganz simpel.

Versucht auch festzustellen, ob der feindliche Bot nicht versucht, einen konstanten Bruch zu verwenden, da Kräfte > Brüche .

EDIT: Ich bin ein Dummy und mein Fraktionsdetektor konnte nicht funktionieren. Jetzt repariert.

def squareUp(hp, history, ties, alive, start):

    #Taken from Geometric Bot
    opponentHP = 100 - sum(history)

    # Need to add case for 1
    if hp == 1:
        return 1

    # Last of the last - give it your all
    if alive == 2:
        if ties == 2 or opponentHP < hp-1:
            return hp - 1

    #Calculate your bet (x^(4/5)) with some variance
    myBet = np.maximum(hp - np.power(hp, 4./5), np.power(hp, 4./5))
    myBet += np.random.randint(int(-hp * 0.05) or -1, int(hp * 0.05) or 1);
    myBet = np.ceil(myBet)
    if myBet < 1:
        myBet = 1
    elif myBet >= hp:
        myBet = hp-1
    else:
        myBet = int(myBet)

    #If total annihilation is a better option, dewit
    if opponentHP < myBet:
        if ties == 2:
            return opponentHP + 1
        else:
            return opponentHP

    #If the fraction is proven, then outbid it (Thanks again, Geometric bot)
    if history and history[0] != history[-1]:
        health = 100
        fraction = float(history[0]) / health
        for i,x in enumerate(history):
            newFraction = float(x) / health
            if newFraction + 0.012*i < fraction or newFraction - 0.012*i > fraction:
                return myBet
            health -= x
        return int(np.ceil(opponentHP * fraction)) + 1    
    else:
        return myBet