Final Sıralaması

+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| İsim | Puanı | WinRate | TieRate | Ortadan Kaldırma Olasılığı |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| 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. ForvetBot | 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. HesaplamaBot | 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. SınırlıRandomBot | 0.00622 | % 0,60 | % 0,05 | [42 39 12 5 2 0]% |
| 34. YayıcıBot | 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. YüzdeBot | 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. AgresifBoundedRandomBotV2 | 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. 0.00088 | % 0,07 | % 0,03 | [37 40 17 5 1 0]% |
| 49. OrtalamaBot | 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]% |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +

Katılan herkese teşekkür eder, kazandıkları için @Sarcoma'yı tebrik ederiz!

Kurallar:

Herkes 100 hp ile başlar. Her rauntta, 2 oyuncu henüz o rauntta yarışmamış olan yarışmacıların havuzundan rastgele seçilir. Her iki oyuncu da 0 ile mevcut hp arasında bir sayı seçer ve bu sayıları aynı anda gösterir. Düşük sayıyı seçen oyuncu hemen ölür. Diğer oyuncu seçtikleri sayıyı kalan hp'lerinden çıkarır ve bir sonraki tura geçer.

Turnuva şöyle çalışır:

Yarışmacıların parantezinden 2 tanesi rastgele seçilir. Yüzleşiyorlar ve biri ya da ikisi ölüyor. Bir oyuncu, eğer ölürse:

1. Rakiplerinden daha küçük bir sayı seçerler
2. HP’leri sıfırın altına veya altına düşüyor
3. Rakipleriyle arka arkaya üç kez bağlanırlar

Kravat durumunda, her iki oyuncu da 3 kata kadar yeni numaralar üretir. Kalkıştan sonra, kurtulan (eğer varsa) bir sonraki tur için havuza taşınır ve mevcut tur havuzunu tüketene kadar süreç tekrarlanır. Havuzda tek bir sayı varsa, tek olan çıkış ücretsiz bir sonraki tura geçer.

Göreviniz bir işlev yazmaktır python2.7 sizin akımı girdi olarak alır hp, rakibin teklifinden bir listesini historyve bir tamsayı tieszaten mevcut rakibinizle bağlı kaç kez anlatır ve nasıl söyler bir tamsayı Birçok bot hala alive(siz dahil) ve startturnuvadaki bot sayısını listeleyen bir tamsayı . Tarihin bağları içermediğini unutmayın. İşlev, 0 ile geçerli toplam hp değeriniz arasında bir tamsayı döndürmelidir. Bağları görmezden gelen birkaç basit örnek aşağıda gösterilmiştir:

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)

İşleviniz hp değerinizden daha büyük bir sayı döndürürse, 0 olarak sıfırlanır. Evet, kendinizi öldürebilirsiniz. İşleviniz, RouletteBot sınıfının herhangi bir nesnesinin hiçbir üyesine erişmeye veya değiştirmeye çalışmamalıdır. Gelecekteki ek botlara bakılmaksızın rakibinizi kesin bir şekilde tanımlayan hiçbir işlem yapmanıza izin verilmez. Yığını denetlemeye, teorik olarak mümkün olduğu sürece, birden fazla farklı rakibin, şu anda yapabilecek olan sadece bir bot olsa bile, ondan topladığınız bilgileri üretebileceği sürece izin verilir. yani, hangi düşman fonksiyonun çağrıldığını görmek için yığında okuyamazsınız.

Bu kurallara göre kazanan yoktur ve son iki yarışmacı birbirini öldürür. Bu durumda her iki finalist de yarım puan alır.

Bu benim ilk programlama bulmacası girişimi, eleştiriler memnuniyetle karşılıyor!

Kontrolör burada bulunabilir .

BinaryBot

Bunu kimse yapmış mı? Her turda sağlığının yarısına bahse girer.

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

SarcomaBot

Son savaş teklifi hp ise - 1. İlk savaş turu teklifi ise, yarım hp artı bir çeyrek hp'ye kadar ek rasgele bir miktar. Bu teklif rakibi hp + 1'den sonra rakipten kesin bir teklif veremezse, rakip teklife göre daha düşük bir sağlığa sahipse,% 75 ile şu anki hp - 1 arasında rastgele miktarda rastgele tutar.

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

Küçük tweaks, yaşam harcamalarını azaltmaya çalışır.

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

İnce Ayarı Güncelle

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

Son giriş

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

UpYoursBot korumasını güncelle eklendi

Güncelleme
AntiAntiUpYoursBot koruması eklendi

Güncelle
AntiAnitAntiAntiUpYoursBot Yenildim

Asýl sen

Girmeye geç kalmakla, bir süredir mevcut botlara hayranlıkla baktım, bir süre çocuklarınızın fikirlerini karmaşıklaştırırken, sonra onları karmaşık hale getirmeden geçirdim. Sonra bana geldi

İyi sanatçılar kopyalar büyük sanatçılar çalar. - Pablo Picasso Beni

"Sevgiler", çünkü ben kesinlikle çalmıyorum (ve bazen botlarınızın tekliflerini bir veya iki tanesine düşürerek).

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

Ama gerçekte, bu büyük bir rekabet adamları. Bu topluluğu, böyle günlerde seviyorum.

intihar uçağı

Neden hepimiz öleceksek, neden karmaşık mantıkla uğraşıyorsun?

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

Tek atış

Kamikaze ile karşılaşmazsa en azından tek bir raundda hayatta kalacaktır.

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

Acıklı Bot çok ihtiyaç duyulan bir yükseltme alır:

Botların diğer botların özelliklerini birleştirmeye çalışan acıklı denemesi

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

Bu bot, daha verimli bot devirleri için Survivalist Bot ve Geometric Bot'un özelliklerini içerir.

Ön Yükseltme:

Rakibin tarihini analiz eden bir botta acıklı deneme

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

Rakibinin önceki bir geçmişi varsa, o zaman rakibinin hp hesaplar. Sonra aşağıdakilerden birini yapar:

• Rakibi yaşayan son rakip ise, o zaman hp'inden daha az teklif verecek.
• Rakibi yaşayan son rakip değilse ama rakibin 16 beygir gücünden daha azına sahipse, rakibinin hp deposunu geçecektir.
• Rakibi, yaşayan son rakip değilse ve bağların bir tarihi varsa, bağları sıkıldığından hp'lerini teklif edecektir.
• Aksi takdirde rakibini geçecektir.

Eğer tarih yoksa, o zaman birlikte kesdiğim bazı fantezi hesaplamaları yapar ve teklif verir. Değer 100'ü aşarsa, otomatik olarak hp eksi 1 değerini verir.

Bu kodu çalışma sırasında birlikte hackledim ve bu benim ilk gönderim, bu yüzden muhtemelen kazanmayacak bir şey olmayacak ve kamikaze'ye kaybedecek.

EDIT: Bazı öneriler nedeniyle, botun başlangıç ​​davranışı daha yüksek bir değer vermek üzere değiştirildi.

2 EDIT: hiçbir şey yapmaz başlangıç ​​param ekledi

3 EDIT: Yeni spinoff bot eklendi:

[Gang Botlara saldıran bir botun acıklı girişimi (yukarıdaki botun yaptığı her şeyi yapmanın yanı sıra)] REMOVED

[Bu bot, rakibinin gangster olup olmadığını analiz eder ve kolayca düşebileceği tatlı düşük teklifleri almak için de öyle görünüyor. ”

Bu bot hurdaya çıkarıldı, lütfen tablodaki tabloyu kaldırın.

EDIT 4: Sabit hatalar, bağlama özelliği değiştirildi.

Kick Bot

Rakibimin ses seçimi hayatının yarısını teklif etmek. Öyleyse, sağlam bir teklifle onu dışarı çıkaramazsak, hayatımızın yarısından daha küçük bir teklif olan yaşamının yarısını + 1 olarak teklif ediyoruz.

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))

Tekme botu açıkçası yumruk botunun düşüğüdür!

Ortalama Tekme Bot

Bu yeni KickBot ilk turda daha yumuşak başladı, bu yüzden sonraki turlarda daha sert atabilir, bu demek oluyor!

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))

Bilge Kick Bot

Her iki kardeşi de intihar etmek zorunda kaldı ama WiseKickBot düşmüş olanlardan öğrendi.

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)

Bir baştankara bot eşdeğer bir girişim. Çoğu bahsin, turlar arasında yaklaşık olarak aynı olduğunu varsayar. Bu varsayımı kullanarak, oldukça tutumlu kalırken düşman botunu yenmeye çalışır. Açılış turunda yaklaşık 40 sağlık harcıyor.

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

SarcomaBot'un UpYours koruması için bir çözüm, kodlarının çoğunu kendi kullanımım için kullanıyor! Veya UpYoursBot kodunu alıyorum? Botumu okurken düşünmek için bir soru ...

AntiAntiUpYours Bot, AntiAntiAntiAntiUpYours Bot olmak için gelişti! Şimdi daha fazla maymun eki ile.

Poli 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, botunuzun geçmişine polinom bir regresyon yapar ve tahmin edilen puanı küçük miktarda atar.

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)

Şık bot iyi vakit geçirdi, ancak erken yatmaya karar verdi. İyi uykular, şık bot.

1/2 Punch Bot, Yeniden Ziyaret Edildi

Bence çok çabuk ölecek. Buna değer. Yeniden adlandırılmış işlev, oradaki adı değiştirmeyi unuttum.

Yenilenmiş versiyon arttı, daha iyi kazanma şansı (son turda daha da fazlası) ve çete botlarından hafif koruma

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

Forvet Bot

1/2 Punch Bot çok fazla zorbalık yaptı ve UpYoursBot'a karşı bile bir roket oldu, böylece abisi StrikerBot yardım etmeye geldi.

Optimize edilmiş 1/2 Punch'dan pek fark bu değil ama biraz daha zeki ve yaptığım koşularda başarılıydı (10k ve 35k, KickbanBot'a kaybedebilir)

Son sürüm doldu, zaman doldu. Bazı sürprizler artmadıkça, birinciliği alamazsanız ikinci sırayı sağlamalıdır (kickbanbotu yenmek için ince bir şans var)

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

Çete Botu

Fikir, botun potansiyel olarak iki veya daha fazlasının aynı simülasyonda kullanılabileceği idi. Bot, tarihinin 7 teklifin katları olup olmadığına bakarak çetedeki diğer botlara "kolay kazanç" vermeye çalışıyor. Elbette bu, diğer botlar tarafından da kolayca manipüle edilebilir. Daha sonra sağlığımın kendi oranlarına ve önceki sağlıklarının önceki tekliflerine oranlarına dayanarak çetesiz botların teklifleri hakkında bir tahmin hesaplıyorum ve 1 ekledim.

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

En kötü durumda

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

Basit bot hp - hp / (start - alive + 4)Çoğu durumda döndürür ve bağlar söz konusu olduğunda, her kravat için 2 sayı artar (bir üst üste!) hp.

Outbidder

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, rakibinin teklif edebileceğinden daha yüksek teklif vermeye çalışacaktır .

Spitball Botu

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

Kalan bot sayısına bağlı olarak sağlığının ne kadar fedakarlık yapacağı hakkında karar verir. Yalnızca iki bot kaldıysa teklif eder hp-1, ancak üç tane kaldıysa, bunun yarısını, dördüncü, üçünü, vb.

Ancak, çok büyük bir yarışmada, ilk turda ölmekten kaçınmak için 3 veya 4 hp'den daha fazla teklif vermem gerekeceğini düşünüyorum, bu yüzden 10'a daha düşük bir sınır koydum. daha hp-1.

Ayrıca birkaç "kravat için 1 hp ekle" botu gördüğüm için kravatlar için 1,5 hp ekliyor. Hile olarak sayıldığından emin değilim. Olursa değiştiririm.

Harika bir fikir, bu arada!

Spitball Bot 2.0

Ne var ne yok?

• Kalan bot sayısı yerine kalan tur sayısına göre bölünmeye geçildi (Teşekkürler @Heiteira!). Aslında, şimdi .8tekliflerimi biraz daha fazla yüklemek için güce yükseltilen bu sayıya bölünüyorum .

• Asgari teklif 10'dan 20'ye düşürüldü (Thanks @KBriggs!)

• Spitball teklifinin rakibin şu anki HP'sinde olup olmadığını kontrol ettim ve eğer öyleyse düşür.

(Buraya metin koymadığım sürece SO, aşağıdaki kodu kod olarak göstermez, bu yüzden Tamam)

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

Geometrik

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

En az çabayla kazancı maksimize etmeye çalışın:

• Kazanabilirsek, sadece yap.
• eğer son tursa, denemek için ölme
• aksi halde, rahatsız etme

Neden?

Olasılıktan yararlanmaya çalışın: İlk raundu düşük oynayarak kazanmak, turnuvaya başlamanın en iyi yoludur. 13 tatlı nokta gibi gözüküyor: ikinci tur kesin bir galibiyet, geri kalan ise parktaki Spaziergang.

Bot tahmin

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)

Buraya ilk kez gönderiyorum. Bu çok eğlenceli görünüyordu, bu yüzden korkunç girişimlerimin ötesine geçiyorum ve diğer botların ne oynayacağını tahmin ediyorum.

Düzenleme 1: İlk bahsinize 1 tane daha ekledim, sadece 51. bahis yapan diğer kişilerle beraber olma olasılığını azaltmak için.

Düzenleme 2: Sarcoma botunun açılış hamlesini çaldı, çünkü ilk önce tutarlı bir şekilde elimine edilmeme ihtimali yüksek.

Düzenleme 3: Bot ilk turda çok iyi hayatta kalır, ancak sonraki aşamalarda kolayca tahrip olur. Robotun, ikinci turdaki düşüncelerini değiştirdi, şimdi yarı bahisçiler suda öldü.

Düzenleme 4: Şimdi ilk turun iyi olduğu için, ikinci turun işleyiş şeklini değiştirdim. İkinci rauntta çok fazla ölmek, bu yüzden bir şekilde hayatta kalmam gerekiyor.

Kan Botu

Bir susuzluk botu öldürmek istedi. Buradaki fikir düşük bahisli botlara karşı kazanmaya çalışmaktır ve ilk turun kan banyosunu geçtikten sonra durdurulamaz olmalı, çünkü düşmanları geride bırakacak HP'nin juggernaut miktarları olmalı.

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

Sadece hp'nin yarısından biraz daha fazla teklif ver

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

Bu bot, düşman botunun geçmişini basit bir şekilde analiz ediyor veya kalan vuruş noktalarının yarısını teklif ediyor

Teklif, daha az sahip olduğunuz rekabetin artmasına neden olur. Gelişmeleri önerdiğiniz için yorum yapanlara teşekkür ederiz.

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 ve HelvsiesBot

Sorularıma cevap verdiğiniz için teşekkür ederim. Sonuç, daha karmaşık bir bottur.

HalvsiesBot, 50/50 kazanma şansıyla botun tuhaf bir 'yarısını geçmeye devam etmesine' dikkat ediyor. Sanırım.

SurvivalistBot, bir kravat üzerindeki geçersiz kılma dahil olmak üzere, veri kümesine dayalı başka kararlar verirse (ikili bağlamayı üçlü bağ ölümünden kaçınmak için 2 bağ kurarsa).

Benim python biraz paslı, bu yüzden kod biraz buggy olabilir, bu yüzden düzeltmek veya güncellemek için çekinmeyin.

Ne kadar HP'nin kaldığı, ne kadar savaşması muhtemel olduğu en az bot sayısı, en az terk etmek için HP miktarı, ortalama teklif gibi sonuçların çıkarılması için veri parçalarını denemek için oluşturulmuştur. Ayrıca, oyun açma veya en iyi teklif verme sorunları gibi belirsiz durumlarda rastgele rasgele yararlanma olanağı sunar.

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

Bot hesaplanıyor

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)

Agresif Hesaplama Botu

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-Tekme 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

Rakibin hareketlerini önceden tahmin edersek, en iyi bahisleri yapabiliriz! Yapamazsak (yeterince veri veya rakip çok rastgele değilse), o zaman en azından kazanma potansiyelimizi en yüksek seviyeye çıkaracak olanı yapabiliriz. Teorik olarak, canlıların sayısının en az yarısı her turda ölecek. Böylece en fazla log2 (canlı) turu olmasını bekleyebilirim. İdeal olarak, hp'mizi tüm turlar arasında eşit bir şekilde bölmeliydik. Ancak, bazı botların aptal olacağını ve erken intihar edeceğini / erken öleceğini biliyoruz, bu yüzden önceki turlarda biraz daha bahis oynamalıyız.

Agresif Hesaplama Bot'un hesaplaması Bot'un uzun vadeli sağlık pahasına, daha agresif davranarak hayatta kalmaya çalışmak için kodu. Sadece simülasyonlar tempo veya değerin kaybolduğunu söyleyecektir.

Kick Anti Bot her zaman mevcut lideri KickBot'u yenmelidir: P

EDIT: Neredeyse tamamen aynı dönüş değerlerine sahip daha akıllı bir bot olan Anti Kick Bot ile Deterministic Bot değiştirildi. Ayrıca, rakip HP'den daha fazla oy kullanmasını da önledi

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))

Gerçekten geç oldu ... Yorgunum ... bir isim düşünemiyorum ... ve bu botun formatı tarihçeye göre biraz farklı bir algoritma ile diğerlerine çok benziyor. Rakibin kumar oynamaya yöneldiği mevcut oranı almaya çalışır ... ya da onun gibi bir şey ... 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

Sahil Botu [Emekli]

Denemeye çalışacak ve hp'leri mermiler arasında eşit bir şekilde bölerek rekabete girecek. İlk turda kalan hp'ye, "kıyıya uygun" turlarda kendini daha iyi yapma şansı vermek için teklif verecek.

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)

Sahil Botu V2

Bu mücadeleyi çok sevdiğimden, sadece bir bot daha yapmak zorunda kaldım. Bu sürüm, ilk iki turda daha fazla hp kullanarak bazılarını daha sonra kıyıya süren hp den fedakarlık eder.

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))

Bot Yüzdesi

Ortalama bg harcamanın harcadığı ortalama yüzde yüzdesini hesaplamaya çalışır ve buna göre teklif verir.

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

Her turda aynı miktarda bahis yapılır. İlk turda hayatta kalabilmek pek mümkün değil, ancak sona erecek kadar şanslıysa, yine de makul miktarda HP kaldı.

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 Botu

Bu bot mevcut lider Mean Kickbot'u birinci turda yenerek ve daha sonra tanıdıkça daha agresif bir şekilde oynayarak karşı koymaya çalışır.

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)

Üç Çeyrek Bot

MehBot veya SarcomaBot (lar) ı yenmeyecek, ama bence gayet iyi. Bu zorluğu ilk gördüğümde, aklıma ilk gelen şey buydu, sebep olmadıkça her zaman sağlığınızın dörtte üçüne bahse girdiniz.

* Düşük turdan sonra ilk raunt.

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

Dört Yedinci Bot

3/4 botun ılımlı başarısından sonra kasabada yeni bir kesir var, bu sadece rasyonel.

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

Mükemmel Kesir

Ben bütünüm

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 herkesin güzel oynamasını istiyor! Eğer rakibi geçen turda güzel olsaydı, diğerlerinde güzel davranışı teşvik etmek için kendini feda eder. Eğer rakibi geçen turda ortalama olsaydı, rakibine mümkün olduğu kadar zarar verecek, gerekirse kendini feda edecekti. Çalışacak geçmişi yoksa, hp'nin üçte birini teklif eder. (Bu botun diğer stratejiler üzerinde ilginç dalgalanma etkileri olacağını umuyorum, bu botun yüksek kazanma oranına sahip olması o kadar değil. Bunlardan birkaçının oyunda olması eğlenceli olabilir)

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, BandaidBot'tan yararlanmak için olması gerektiği kadar güzel olacaktır. Rakibini bundan daha az bir süre için öldüremediği sürece, gücünün üçte birinin altına geri dönecek. Rakibi BandaidBot'a benziyorsa, BandaidBot'un 1'i teklif edeceğini bilerek 2'yi ödeyecek, çünkü GetAlongBot diğerleriyle çok iyi geçiniyor - diğer tarafta gerçekten BandaidBot olduğu sürece kolay bir galibiyet.

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)

TENacious 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

Bu bot en sevdiği değeri 10 olarak tutmaya çalışır, ancak bir bağı kırmak (gerektiğinde iki katı veya dörtlü) veya gerektiğinde tur atmak için gerektiğinde zaman zaman tercihini değiştirir; Rakipler ve herhangi bir zamanda 2'den daha az teklif vermeyi düşünmek istemiyor, çünkü rakibin 1'den daha az teklif vermesini ummaktan çok daha iyidir.

Not: 2 ^ 9'dan fazla bot varsa, bu botun stratejik problemleri olabilir.

CautiousBot

Programlama Bulmacalarına şimdiye kadar ilk başvuru! Mücadelenizi oldukça ilginç buldum: P

Son tur bit hp'den daha azsa, tarihçe yarım hp ve küçük bir rasgele miktarla oynamazsanız.

Geçmişi, rakip hp ve kalan mermi sayısını kontrol edip kalan hp sayısına kalan ek mertebeden fazladan bir tampon kullanarak rakip hp / 2'yi geçmeyi deneyin. . Çok fazla hp harcadığınızı kontrol edin (kendinizi öldürmeyin veya rakiplerinizden daha fazla teklif vermeyin).

Diğer botların yaptığı gibi bağları her zaman düzeltin.

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

İlk turlarda çok agresif, şimdi CautiousBot daha da temkinli ...

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)

Tamam, bu konuda elimi deneyeceğim.

SnetchBot

Rakibin gittiği sağlık fraksiyonlarını kontrol etmek. Eğer rakip yükseltirse, onu yen.

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

EDIT: ilk rauntta çok şey kaybederek ilk sıradaki rastgele limitleri ayarladı.

SquareUpBot

Pek çok bot kesirler yerine güçlerle oynuyor gibi görünmüyordu, ben de bazı standart optimizasyonlarla bir tane yapmaya karar verdim ve nereye koyacağımı görmeye karar verdim. Oldukça basit.

Ayrıca, düşman botunun bazı sabit kesirleri kullanmaya çalışmadığından emin olunmaya çalışın, çünkü güçler > kesirler .

EDIT: Ben bir kukla değilim ve kesir dedektörüm işe yaramadı. Şimdi tamir edildi.

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