Robot Roulette: Taruhan robot taruhan tinggi

56

Peringkat Terakhir

+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| Nama | Skor | WinRate | TieRate | Peluang Eliminasi |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| 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]% |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +

Terima kasih untuk semua yang berpartisipasi, dan selamat kepada @Sarcoma atas kemenangannya!

Aturan:

Semua orang mulai dengan 100 hp. Setiap putaran, 2 pemain dipilih secara acak dari kumpulan kontestan yang belum berkompetisi di babak itu. Kedua pemain memilih angka antara 0 dan hp mereka saat ini, dan mengungkapkan angka-angka itu secara bersamaan. Pemain yang memilih angka yang lebih rendah segera mati. Pemain lain mengurangi nomor yang mereka pilih dari hp mereka yang tersisa dan melanjutkan ke babak berikutnya.

Turnamen bekerja seperti ini:

Dari kelompok kontestan, 2 dipilih secara acak. Mereka berhadapan, dan satu atau keduanya mati. Seorang pemain mati jika:

  1. Mereka memilih angka yang lebih kecil dari lawan mereka
  2. HP mereka turun ke atau di bawah nol
  3. Mereka mengikat tiga kali berturut-turut dengan lawan mereka

Dalam kasus ikatan, kedua pemain cukup menghasilkan angka baru, hingga 3 kali. Setelah faceoff, orang yang selamat (jika ada) dipindahkan ke kolam untuk putaran berikutnya, dan prosesnya diulang sampai kita telah menghabiskan kolam putaran saat ini. Jika ada nomor ganjil di kolam, maka yang ganjil pindah ke babak berikutnya secara gratis.

Tugas Anda adalah menulis fungsi dalam python2.7 yang mengambil input saat ini hp, daftar tawaran lawan history, dan bilangan bulat tiesyang memberi tahu Anda berapa kali Anda telah terikat dengan lawan saat ini, dan bilangan bulat yang memberi tahu Anda bagaimana masih banyak bot alive(termasuk Anda), dan bilangan bulat yang mencantumkan jumlah bot di startturnamen. Perhatikan bahwa riwayat tidak termasuk ikatan. Fungsi harus mengembalikan bilangan bulat antara 0 dan total hp Anda saat ini. Beberapa contoh sederhana, yang mengabaikan ikatan, ditunjukkan di bawah ini:

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)

Jika fungsi Anda mengembalikan angka yang lebih besar dari hp Anda, maka akan diatur ulang ke 0. Ya, Anda dapat bunuh diri. Fungsi Anda tidak boleh mencoba mengakses atau mengubah sembarang anggota objek apa pun dari kelas RouletteBot. Anda tidak diizinkan untuk mengambil tindakan apa pun yang secara jelas mengidentifikasi lawan Anda terlepas dari bot tambahan di masa mendatang. Memeriksa tumpukan diperbolehkan selama secara teori dimungkinkan bahwa lebih dari satu lawan yang berbeda dapat menghasilkan informasi yang Anda peroleh darinya, bahkan jika hanya ada satu bot yang ada saat itu. yaitu, Anda tidak bisa hanya membaca tumpukan untuk melihat fungsi musuh yang dipanggil.

Di bawah peraturan ini dimungkinkan bahwa tidak ada pemenang, dan dua kontestan terakhir saling membunuh. Dalam hal ini, kedua finalis mendapat setengah poin masing-masing.

Ini adalah upaya teka-teki pemrograman pertama saya, jadi kritik dipersilahkan!

Kontroler dapat ditemukan di sini .

KBriggs
sumber
4
FWIW, saya berencana untuk menggunakan jaringan saraf yang dilatih pada semua bot lainnya hanya untuk bersenang-senang setelah Anda mengatur controller :)
Quintec
2
Pemeriksaan tipe adalah untuk kepentingan antiantiantiantiupyoursbot. Saya akan mencari cara lain
KBriggs
3
@Sarcoma Sepertinya kompetisi ini telah memicu perang kode yang serius. Kompetisi ini belum berakhir, tetapi saya sudah menantikan evolusi ini. Mungkin bahkan langkah selanjutnya, AI meningkatkan kompetisi: P
Markov Dirantai
3
WOOOOOOOOOOOOOO!
Sarkoma
5
Ya Tuhan. Trolling yang disengaja dari mengubah mean_kick untuk selalu mengembalikan nol ketika digunakan begitu banyak tempat adalah brilian.
Magua

Jawaban:

12

BinaryBot

Adakah yang sudah melakukan ini? Taruhan setengah kesehatannya setiap lantai berlantai.

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

SarcomaBot

Jika tawaran pertempuran terakhir, hp - 1. Jika itu adalah tawaran putaran pertama pertempuran, setengah hp ditambah jumlah acak tambahan hingga seperempat hp. Jika ia dapat mengalahkan tawaran langsung lawan setelah tawaran tersebut, lawan + hp. 1. Jika memiliki kesehatan yang lebih rendah daripada tawaran acak lawan, jumlah antara 75% dan ini adalah hp saat ini - 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

Perbaikan kecil berupaya untuk mengurangi pengeluaran seumur hidup.

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

Perbarui Fine Tuning

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

Entri Terakhir

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

Perbarui
perlindungan UpYoursBot ditambahkan

Perbarui
perlindungan AntiAntiUpYoursBot ditambahkan

Perbarui
AntiAnitAntiAntiUpYoursBot Saya dikalahkan

Sarkoma
sumber
Komentar bukan untuk diskusi panjang; percakapan ini telah dipindahkan ke obrolan .
Mego
17

Terserah Anda

Terlambat masuk, aku menghabiskan waktu mengagumi bot yang ada, menghabiskan waktu terlalu rumit ide-ide kalian, kemudian membatalkan rumit mereka. Lalu itu datang kepada saya

Artis yang bagus meniru, seniman hebat mencuri. - Pablo Picasso Me


"Up Yours" karena saya mencuri tanpa malu-malu (dan kadang-kadang memasukkan satu atau dua poin ke tawaran bot Anda untuk menambah mereka).

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

Tapi yang sebenarnya, ini adalah kompetisi yang hebat kawan. Saya suka komunitas ini pada hari-hari seperti ini.

Qfwfq
sumber
1
Hahahaha ini cantik sekali. Saya ragu-ragu apakah saya harus mengizinkannya, tetapi saya akan membiarkannya untuk saat ini karena saya tidak berpikir untuk mengatakan itu tidak diperbolehkan. Anda salah nama fungsi di beberapa tempat - lihat controller di github.
KBriggs
1
Itu memang sangat baik, tetapi masih kalah dari Kick Bot
KBriggs
1
Ha, usaha yang bagus!
Sarkoma
1
@Sarcoma, aku tidak bisa melakukannya tanpamu. ;) Saya sangat suka bot Anda juga, sobat.
Qfwfq
1
Perlindungan Upyoursbot dari Sarcomabot benar-benar mengacaukan yang satu ini
KBriggs
15

Kamikaze

Kenapa repot-repot dengan logika yang rumit ketika kita semua akan mati ...

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


Satu tembakan

Ini akan bertahan setidaknya satu putaran jika tidak menemui kamikaze.

 def one_shot(hp, history, ties, alive):
      if hp == 1:
          return 1
      else:
          return hp - 1
DobromirM
sumber
11
Welp, itu tak terhindarkan
KBriggs
Saya akan menambahkan bot pasifis juga, tetapi saya tidak ingin membanjiri tantangan Anda dengan bot mati otak
DobromirM
5
Berdasarkan beberapa pengujian cepat, bot kamikaze tidak banyak berubah - yang dilakukannya hanyalah menghapus bot lain dari ronde secara acak, yang, lebih dari cukup banyak turnamen, rata-rata hanya nol. Yang Satu panas rapi. Tanpa itu, AverageBot saya cenderung melakukan yang terbaik - tetapi jika ada beberapa OneShots yang sedang dimainkan, ini akan memiringkan rata-rata ke angka besar dan cenderung membuat AverageBot mati dengan cepat. Sama untuk LastBot. Anda benar-benar dapat mengacaukan perilaku robot lain dengan mengubah pola taruhan Anda sendiri. Dengan OneShot dalam permainan, RandomBot menang. Tanpa itu, AverageBot menang.
KBriggs
14

Bot Menyedihkan mendapat upgrade yang sangat dibutuhkan:

Upaya menyedihkan pada bot yang mencoba menggabungkan fitur bot lain

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

Bot ini menggabungkan fitur dari Survivalist Bot dan Geometric Bot untuk penghapusan bot yang lebih efisien.

Pra-Peningkatan:

Upaya menyedihkan pada bot yang menganalisis sejarah lawannya

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

Jika ada riwayat lawannya sebelumnya, maka ia menghitung hp lawannya. Kemudian, ia melakukan salah satu dari yang berikut:

  • Jika lawannya adalah lawan terakhir yang masih hidup, maka ia akan menawar satu kurang dari hp-nya.
  • Jika lawannya bukan lawan terakhir yang masih hidup tetapi lawannya memiliki kurang dari 16 hp, maka ia akan kalah dari hp lawannya.
  • Jika lawannya bukan lawan terakhir yang masih hidup dan ada riwayat ikatan, maka itu akan menawar hpnya karena bosan dengan ikatan.
  • Jika tidak, itu akan mengalahkan lawannya.

Jika tidak ada riwayat, maka ia melakukan beberapa perhitungan mewah yang saya retas bersama dan menawarnya. Jika nilainya melebihi 100, maka secara otomatis akan menawar hp minus 1.

Saya meretas kode ini bersama-sama saat bekerja dan ini adalah pengiriman pertama saya, jadi mungkin tidak akan menang atau apa pun, dan itu akan kalah oleh kamikaze.

EDIT: Karena beberapa saran, perilaku awal bot telah diubah untuk menawar nilai yang lebih tinggi.

EDIT 2: menambahkan start param yang tidak melakukan apa-apa

EDIT 3: Menambahkan bot spin-off baru:

[Upaya menyedihkan pada bot yang menyerang Gang Bots (dan juga melakukan semua yang dilakukan bot di atas)] DIHAPUS

[Bot ini menganalisis apakah lawannya adalah gangbot atau tidak dan berpura-pura menjadi satu juga untuk mendapatkan tawaran rendah yang manis sehingga dapat dengan mudah mengalahkannya.]

Bot ini telah dihapus, harap lepaskan dari papan peringkat.

EDIT 4: Memperbaiki kesalahan, mengubah fitur dasi.

Yodie
sumber
Bagus sekali, terima kasih untuk botnya! Saya akan memberikan beberapa statistik ketika saya mendapatkan beberapa lagi.
KBriggs
Saya seorang pemula di python jadi saya tidak yakin apakah sintaksinya benar, jangan ragu untuk memberi tahu saya jika itu terjadi
Yodie
Ini berjalan, jadi jangan khawatir di sana
KBriggs
@Yodie Sebagai ulasan kode mini: Badan fungsi Anda harus diindentasi oleh level (keperluan sintaksis); opp_hp +1tidak ada ruang untuk menjadi pythonic; komentar Anda mulai dengan spasi kosong yang tidak seimbang. Akhirnya, fungsi Anda kurang docstring.
Jonathan Frech
2
Saya pikir bot ini cukup baik jika berhasil melewati putaran pertama, tetapi karena begitu banyak orang bertaruh besar, dia putaran pertama hampir selalu mati lebih awal. Anda dapat meningkatkan kinerja dengan mengubah perilaku awal untuk menawar lebih tinggi ketika tidak ada riwayat. Misalnya, jika Anda melipatgandakan taruhan no-histori Anda, bot ini menang dengan selisih nyaman di antara para kontestan sejauh ini.
KBriggs
11

Kick Bot

Pilihan suara untuk lawan saya adalah menawar setengah dari hidupnya. Lalu kami menawar hingga setengah dari hidupnya + 1 jika kami tidak dapat membawanya keluar dengan tawaran yang masuk akal, yaitu tawaran yang lebih kecil dari setengah dari kehidupan kami.

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

Bot tendangan jelas merupakan musuh bot pukulan!

Bot Tendangan Berarti

KickBot baru ini menendang lebih lembut di babak pertama supaya dia bisa menendang lebih keras di putaran berikutnya, itu artinya!

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

Bot Tendangan Bijaksana

Kedua saudaranya harus bunuh diri tetapi WiseKickBot belajar dari yang jatuh.

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))
Johan
sumber
Bagus. Saya melihat banyak kiriman yang secara langsung melawan orang lain sekarang, itulah yang saya harapkan
KBriggs
Pengembalian dua kali lipat pada baris terakhir?
Veskah
Ah saya belum menjalankannya atau saya akan menangkapnya.
KBriggs
Yang ini telah memimpin dengan nyaman!
KBriggs
1
@ KBriggs di sini ada cadangan!
Johan
8

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)

Upaya setara dengan bot tit-for-tat. Asumsikan sebagian besar taruhan kira-kira sama di antara putaran. Menggunakan asumsi itu, ia mencoba untuk mengalahkan bot musuh sambil tetap cukup hemat. Menghabiskan sekitar 40 kesehatan di babak pembukaan.

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

Solusi untuk perlindungan anti-UpYours dari SarcomaBot, mendapatkan sebagian besar kode mereka untuk saya gunakan sendiri! Atau apakah saya mengambil kode UpYoursBot? Sebuah pertanyaan untuk direnungkan saat Anda membaca bot saya ...

AntiAntiUpYours Bot telah berevolusi menjadi AntiAntiAntiAntiUpYours Bot! Sekarang dengan lebih banyak monyet-patching.

Bot poli

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 melakukan regresi polinomial pada sejarah bot Anda, dan mengalahkan skor yang diprediksi dengan jumlah kecil.

Bot berkelas

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)

Bot berkelas telah bersenang-senang, tetapi telah memutuskan untuk tidur lebih awal. Tidur nyenyak, bot berkelas.

Persona
sumber
Komentar bukan untuk diskusi panjang; percakapan ini telah dipindahkan ke obrolan .
Mego
8

1/2 Bot Pukulan, Dikunjungi Kembali

Saya pikir itu akan mati dengan cepat. Setimpal. Berganti nama fungsinya, lupa mengubah nama di sana.

Versi yang dikunjungi kembali, peluang yang lebih baik untuk menang (bahkan lebih di babak final) dan sedikit perlindungan dari geng bot

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

Striker Bot

1/2 Punch Bot terlalu sering diintimidasi dan bahkan menjadi antek untuk UpYoursBot sehingga kakaknya, StrikerBot , datang untuk membantu.

Tidak banyak perbedaan dari dioptimalkan 1/2 Punch tapi dia sedikit lebih pintar dan melakukannya dengan baik dalam menjalankan saya lakukan (10k dan 35k, meskipun dia mungkin kalah dari KickbanBot)

Versi terakhir, waktu habis. Kecuali jika beberapa kejutan muncul, itu akan mengamankan posisi kedua, jika tidak mendapatkan yang pertama (ada peluang tipis untuk mengalahkan kickbanbot)

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
Belhenix
sumber
Anda harus mengganti namanya, sudah ada bot kamikaze ^ _ ^
KBriggs
Sejauh ini yang ini adalah pemenangnya
KBriggs
Fungsi Anda ceiltampaknya tidak ditentukan.
Jonathan Frech
Saya mengubah ke np.ceil () untuk menjalankannya
KBriggs
telah diedit, terima kasih untuk informasi sebelumnya
Belhenix
7

Bot geng

Idenya adalah bahwa berpotensi dua atau lebih bot dapat digunakan dalam simulasi yang sama. Bot mencoba untuk memberikan "kemenangan mudah" untuk bot lain di geng, dengan melihat apakah sejarahnya adalah kelipatan dari 7 penawaran. Tentu saja, ini bisa dengan mudah dimanipulasi oleh bot lain juga. Lalu saya menghitung tebakan pada tawaran bot non-geng berdasarkan rasio kesehatan saya dan rasio kesehatan mereka sebelumnya terhadap tawaran sebelumnya dan menambahkan 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
Jim Hat
sumber
Sangat keren. Berapa banyak yang dibutuhkan? Saya mungkin harus membatasi jumlah entri ...
KBriggs
Blok kode Anda tampaknya ketinggalan baris pertama sumber Anda.
Jonathan Frech
Saya tidak yakin berapa banyak yang akan dibutuhkan dalam simulasi, tetapi jika ada bot yang melihat satu sama lain, mereka harus meningkatkan peluang salah satu dari mereka menang. Saya menduga memiliki 10% dari kolam menjadi geng bot harus cukup untuk membuat perbedaan yang signifikan. Juga blok kode melewatkan hal baris pertama -> ini adalah posting pertama saya di sini. Saya tidak tahu mengapa pemformatan melakukan itu tetapi ya itu hanya deklarasi metode.
Jim Hat
Anda memiliki bug: bot akan mengidentifikasi siapa saja dengan len (history)> 1 sebagai anggota geng
KBriggs
Buruk saya, harus diperbaiki sekarang.
Jim Hat
6

Kasus terburuk

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

Bot sederhana. Pengembalian hp - hp / (start - alive + 4)untuk sebagian besar kasus, dan dalam kasus ikatan meningkatkannya dengan 2 (harus naik satu) untuk setiap dasi, pastikan untuk tidak mengembalikan nomor lebih dari ituhp .

Quintec
sumber
Ini gagal dengan membagi dengan nol jika alive==8. Saya dapat secara manual mengubahnya ke jumlah bot total, tetapi ini memperluas aturan karena itu bukan input ke fungsi Anda - yang Anda tahu jika ada berapa banyak lawan yang tersisa pada waktu tertentu, bukan berapa banyak Anda mulai menentang.
KBriggs
Saya memperbarui kontes berdasarkan permintaan Anda
KBriggs
@ KBriggs Terima kasih :)
Quintec
Anda juga perlu menambahkan 1 untuk memulai-hidup, karena ini adalah 0 untuk putaran pertama
KBriggs
@ KBriggs diperbaiki, sebenarnya harus +2 sehingga tidak mengembalikan 0, lol
Quintec
6

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 akan berusaha untuk menawar lebih tinggi dari yang dapat ditawar lawannya jika memungkinkan.

Draco18s
sumber
Ada kondisi yang where np.random.randint(hp/5, hp/2)bisa gagal jika hp/5 == hp/2, yaitu jika hp==0atauhp==1
KBriggs
3
Jika HP 0, maka saya seharusnya tidak dipanggil. : P Anda benar tentang HP 1.
Draco18s
6

Bot Spitball

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

Membuat penilaian tentang seberapa banyak kesehatan yang harus dikorbankannya berdasarkan jumlah bot yang tersisa. Jika hanya ada dua bot yang tersisa, itu tawaranhp-1 , tetapi jika ada tiga , itu menggigit setengahnya, empat kiri, ketiga, dll.

Namun, dalam kontes yang sangat besar, saya rasa saya harus menawar lebih dari 3 atau 4 hp untuk menghindari kematian pada putaran pertama, jadi saya telah menempatkan batas bawah pada 10. Tentu saja, saya masih tidak akan pernah menawar lebih banyak dari hp-1 .

Ini juga menambahkan 1,5 hp untuk dasi, karena saya melihat beberapa bot "tambahkan 1 hp untuk dasi". Saya tidak yakin apakah itu dianggap curang. Jika ya, saya akan mengubahnya.

Ngomong-ngomong, ide bagus!

Bot Spitball 2.0

Apa yang baru?

  • Beralih ke pembagian dengan jumlah putaran yang tersisa alih-alih jumlah bot yang tersisa (Terima kasih kepada @Heiteira!). Sebenarnya, saya sekarang membagi dengan jumlah yang dinaikkan ke kekuasaan.8 , sehingga untuk memuat di depan tawaran saya sedikit lebih.

  • Menaikkan tawaran minimum dari 10 hingga 20 (Terima kasih @KBriggs!)

  • Dimasukkan cek apakah tawaran spitball lebih dari HP lawan saat ini, dan turunkan jika itu.

(SO tidak akan merender kode di bawah ini sebagai kode kecuali saya meletakkan teks di sini, jadi 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
MegaWidget
sumber
1
Tawaran Anda harus berupa bilangan bulat, sehingga selama Anda menghitung nilai dasar untuk menghilangkan desimal, tidak apa
KBriggs
Yap, saya melakukannya dengan benar setelah melakukan semua perhitungan. Terima kasih atas balasan cepatnya!
MegaWidget
2
Anda mungkin dapat mengoptimalkan ini jika Anda tidak membagi hp Anda dengan jumlah kontestan yang tersisa tetapi dengan jumlah putaran yang tersisa (yang seharusnya adalah math.ceil (math.log (hidup, 2))
Black Owl Kai
1
Berdasarkan bot lain, sebagian besar dari mereka tampaknya menawarkan tawaran di depan, jadi ini mungkin lebih baik jika Anda meningkatkan tawaran putaran pertama di atas 10
KBriggs
Keduanya adalah ide bagus! Saya tidak menyadari bahwa jumlah bot tidak sama dengan jumlah putaran yang tersisa (saya salah menafsirkan aturan kontes pada awalnya). Saya akan mencoba menerapkannya besok. Terima kasih!
MegaWidget
5

Geometris

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)
Mnemonik
sumber
Posisi
5

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

Cobalah untuk memaksimalkan kemenangan dengan sedikit usaha:

  • jika kita bisa menang, lakukan saja
  • jika ini babak terakhir, jangan mati mencoba
  • jika tidak, jangan repot-repot

Mengapa?

Cobalah untuk memanfaatkan peluang: memenangkan putaran pertama dengan bermain rendah adalah cara terbaik untuk memulai turnamen. 13 tampaknya menjadi sweet spot: putaran kedua pasti menang, dan sisanya adalah Spaziergang di taman.

GB
sumber
Anda telah memimpin, sangat bagus! Hati-hati, Anda mungkin ingin menambahkan perlindungan parasit, karena bot yang memimpin menjadi target untuk hal-hal seperti UpYoursBot. Lihat SarcomaBots untuk ide perlindungan jika Anda membutuhkannya.
KBriggs
5

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

Pertama kali memposting di sini. Ini terlihat sangat menyenangkan jadi saya mengirimkan upaya saya yang luar biasa dan menebak apa yang akan bertaruh oleh bot lain.

Sunting 1: Menambahkan 1 lainnya ke taruhan pertama, hanya untuk mengurangi peluang dasi dengan orang lain bertaruh 51.

Sunting 2: Mencuri langkah pembukaan bot Sarcoma karena memiliki peluang bagus untuk tidak dihilangkan lebih dulu secara konsisten.

Sunting 3: Bot bertahan dengan sangat baik di babak pertama, tetapi sedang dihancurkan dengan mudah pada tahap selanjutnya. Mengubah cara robot berpikir tentang putaran kedua sekarang bahwa setengah atasannya sudah mati di dalam air.

Sunting 4: Sekarang karena babak pertama baik, saya mengubah cara menangani putaran kedua. Sekarat banyak di babak kedua jadi saya harus bertahan hidup entah bagaimana.

Bot darah

Membuat bot haus mencari pembunuhan. Idenya adalah untuk mencoba menang melawan bot taruhan rendah dan setelah melewati pertumpahan darah pada putaran pertama itu harus tak terbendung karena harus memiliki jumlah raksasa HP untuk mengalahkan musuh.

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)
Markov Dirantai
sumber
2
Saya pikir len (history) * len (history) dapat diubah menjadi len (history) ** 2 jika pengetahuan saya tentang python benar.
Yodie
Anda memiliki pembagian dengan nol untuk saat len ​​(history) == 0
KBriggs
Kode telah diperbarui. Setelah menemukan tidak ada sejarah itu pergi ke yang lain
Markov Dirantai
oi .............
Sarcoma
2
@Sarcoma itu adalah dunia bot yang kejam di luar sana, man!
Markov Dirantai
5

meh_bot

Tawaran saja lebih dari setengah hp-nya

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
meh Man
sumber
Ada beberapa bot yang ada untuk mengambil keuntungan dari perilaku ini, jadi Anda mungkin akan kesulitan mendapatkan traksi!
KBriggs
@KBriggs Membuat beberapa pembaruan, saya tidak mengharapkan versi pertama untuk melakukan seperti halnya semoga, semoga, pembaruan ini akan memberikannya kesempatan yang lebih besar
meh Man
Wow, itu membuat perbedaan besar, saya pikir Anda yang pertama. Pembaruan akan diposting dalam beberapa menit. Anda mungkin perlu memberi bot Anda sistem kekebalan tubuh (Lihat SarcomaBot) jika Anda ingin melakukan ini dengan baik.
KBriggs
@ KBriggs Saya tidak berharap untuk melakukan ini dengan baik, saya pikir yang terbaik itu akan menjadi top 10. Bagaimanapun saya telah menambahkan yang lain hanya untuk melihat efek hp putaran pertama. Bisakah Anda menjalankan keduanya sehingga saya bisa melihat hasil keduanya? Terima kasih
meh Man
@KBriggs Tolong lakukan ini juga, Muchas gracias
meh Man
4

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

Bot ini melakukan beberapa analisis sederhana tentang sejarah bot musuh, atau menawar setengah dari poin hit yang tersisa

Belgabad
sumber
4

Tawaran lebih tinggi semakin sedikit kompetisi yang Anda miliki. Terima kasih kepada komentator karena menyarankan perbaikan.

def Spreader(hp, history, ties, alive):
   if alive == 2:
       return hp-1
   if len(history) < 2:
       return hp/2
   return np.ceil(hp/alive)
Gus314
sumber
1
Ide yang rapi, tapi saya melihat dua masalah. Salah satunya adalah tawaran bot lain yang besar di babak pertama, jadi yang ini mungkin akan mati lebih awal. Yang kedua adalah bahwa di final, kebanyakan bot menawar hp-1, jadi yang ini akan kehilangan mereka kecuali Anda memiliki dua kali lipat hp mereka. Tapi untuk putaran menengah saya suka ide itu. Jika Anda menangani dua kasus khusus, Anda mungkin dapat meningkatkan kinerja.
KBriggs
4

SurvivalistBot dan HalvsiesBot

Terima kasih telah menjawab pertanyaan saya. Hasil akhirnya adalah bot yang lebih kompleks.

HalvsiesBot adalah bot 'aneh terus saja setengah' dengan peluang menang 50/50. Saya kira.

SurvivalistBot membuat serangkaian pohon biner jika ada keputusan berdasarkan pada dataset, termasuk menimpa dasi (jika menyentuh 2 ikatan itu kamikaze untuk menghindari kematian triple tie).

Python saya agak berkarat, jadi kodenya mungkin sedikit bermasalah, jadi jangan ragu untuk memperbaikinya atau memperbaruinya.

Itu dibangun untuk mencoba mencari bit data untuk menyimpulkan hal-hal seperti berapa banyak HP yang tersisa, jumlah minimum bot yang kemungkinan akan diperjuangkan, jumlah minimum HP yang tersisa, penawaran rata-rata. Ini juga mengeksploitasi pengacakan dalam situasi ambigu, seperti pembukaan drama atau masalah penawaran yang optimal.

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
SSight3
sumber
Opponent_Average_Bid = Opponent_Remaining_HP / float(len(history)) ZeroDivisionError: float division by zero. Baris ini perlu menangani kasus 0 length history.
KBriggs
Terima kasih, saya akan memperbaikinya.
SSight3
Tetap. Beri tahu saya jika ada kesalahan lainnya.
SSight3
1
Beberapa kesalahan sintaks: hilang: `setelah else, math.[func] -> np.[func]dan pada satu titik Anda gunakan Lowestdi mana Anda maksud LowestBid. Semua diperbaiki di controller pada github dan skor diperbarui segera.
KBriggs
Terima kasih. Memperbaiki semua kesalahan yang disebutkan di pos.
SSight3
4

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

Bot Menghitung Agresif

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)

Bot Anti Tendangan

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

Jika kita dapat memprediksi tindakan lawan, kita dapat membuat taruhan yang optimal! Jika kita tidak bisa (tidak cukup data atau lawan terlalu acak), maka kita setidaknya bisa melakukan apa yang akan memaksimalkan potensi kemenangan kita. Secara teoritis setidaknya setengah jumlah bot hidup akan mati setiap putaran. Jadi saya bisa berharap ada paling banyak putaran log2 (hidup). Idealnya kami akan membagi hp kami secara merata di antara semua putaran. Namun, kita tahu bahwa beberapa bot akan menjadi bodoh dan bunuh diri / mati lebih awal, jadi kita harus bertaruh lebih banyak pada putaran sebelumnya.

Agresif Menghitung Bot memodifikasi kode Menghitung Bot untuk mencoba tetap hidup dengan menjadi lebih agresif, dengan mengorbankan kesehatan jangka panjang. Hanya simulasi yang akan menunjukkan apakah tempo atau nilai menang.

Anti Kick Bot harus selalu mengalahkan pemimpin saat ini KickBot: P

EDIT: Bot Deterministik yang Diganti dengan Anti Kick Bot, bot yang lebih cerdas dengan nilai pengembalian yang hampir sama persis. Juga mencegah pemungutan suara lebih dari lawan HP

Bob Cratchit
sumber
Imut. Saya pikir ini akan lebih baik dengan kolam bot yang sangat besar.
KBriggs
Saya mendapatkan error kadang-kadang dengan yang satu ini: return np.max(theoreticalBet, hp - 1): AxisError: axis 23 is out of bounds for array of dimension 0. Saya memposting tautan ke controller sehingga Anda dapat mengujinya.
KBriggs
@ KBriggs Memperbarui kode untuk memperbaikinya.
Bob Cratchit
1
dikonfirmasi, pembaruan skor masuk. Anda berada di 10 besar pasti.
KBriggs
@KBriggs Saya menambahkan beberapa bot lagi untuk dicoba :)
Bob Cratchit
4

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

Ini sangat terlambat ... Saya lelah ... tidak bisa memikirkan nama ... dan format bot ini sangat mirip dengan yang lain, hanya dengan algoritma yang sedikit berbeda mengingat sejarah. Itu mencoba untuk mendapatkan tingkat saat ini yang cenderung lawan terhadap judi ... atau sesuatu seperti itu ... zzz

Quintec
sumber
Anda harus menggunakan np.maximumsebagai ganti np.max, sama untukmin
KBriggs
@ KBriggs Terima kasih :) Hmm, sepertinya bot generik menguasai game ini
Quintec
Sepertinya mereka akan menjadi target yang cukup mudah, saya terkejut belum ada yang membuat parasit
KBriggs
@ KBriggs Ya, saya terkejut. Saatnya menambahkan perlindungan ...
Quintec
Masih berencana membuat neuralbot?
KBriggs
4

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
Roo4data
sumber
4

Coast Bot [Pensiun]

Akan mencoba dan meluncur melalui kompetisi dengan membagi hp itu secara merata di antara putaran. Akan menawar sisa hp pada putaran pertama untuk memberikan kesempatan yang lebih baik untuk membuatnya ke putaran "mampu-pantai".

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

Karena saya sangat menyukai tantangan ini, saya hanya perlu membuat bot lain. Versi ini mengorbankan beberapa dari itu kemudian meluncur hp dengan menggunakan lebih banyak hp di dua putaran pertama.

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

Persen Bot

Mencoba menghitung rata-rata persentase pengeluaran hp lawan, dan tawaran berdasarkan itu.

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)
Wazz
sumber
Ide yang sangat keren. Memecat babak pertama adalah tren baru dalam bot, dan tampaknya bekerja dengan cukup baik.
KBriggs
@ KBriggs Saya telah memperbarui respons ini untuk memuat upaya kedua saya. Menyebutkan Anda sesuai aturan baru. Btw puzzle bagus!
Wazz
Ingin saya memasukkan keduanya, atau hanya versi terbaru? Sekarang ini hanya V2
KBriggs
@ KBriggs Saya ingin keduanya masuk jika tidak apa-apa. Akan bagus untuk melihat bagaimana mereka menimbang satu sama lain.
Wazz
Performa yang hampir serupa secara keseluruhan
KBriggs
4

ConsistentBot

Taruhan dalam jumlah yang sama setiap putaran. Ini tidak terlalu mungkin untuk selamat dari putaran pertama, tetapi jika cukup beruntung untuk sampai pada akhir, itu masih harus memiliki jumlah HP yang masuk akal.

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
Kevin - Pasang kembali Monica
sumber
Whelp, sudah terlambat untuk memperbaikinya sekarang, tetapi bot saya menggunakan cukup HP untuk mencapai akhir pertempuran setiap lawan, tidak sampai ke babak terakhir. Itu salah saya: P
Kevin - Reinstate Monica
4

Bot Kickban

Bot ini hanya mencoba untuk melawan pemimpin saat ini Mean Kickbot dengan mengalahkannya di ronde satu dan bermain lebih agresif sesudahnya jika mengenalinya.

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)
HRSE
sumber
1
Saya pikir lekukan Anda sedikit tidak beres.
Jonathan Frech
oops, terima kasih, editor kode aneh mengacaukan baris pertama
HRSE
pelajaran berharga dalam mempercayai kode yang tidak Anda kendalikan
OganM
4

Bot Tiga Perempat

Dia tidak akan mengalahkan MehBot atau SarcomaBot (s), tapi saya pikir dia melakukannya dengan cukup baik. Ketika saya pertama kali melihat tantangan, ini adalah hal pertama yang muncul di benak saya, selalu bertaruh tiga perempat kesehatan Anda kecuali tidak ada alasan untuk itu.

* setelah rendah putaran babak pertama.

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

Four Sevenths Bot

Setelah sukses moderat 3/4 bot ada fraksi baru di kota, itu hanya rasional.

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

Fraksi Sempurna

Saya utuh

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
Joshua Webb
sumber
Berdasarkan probabilitas penghapusan ini, Anda mungkin bisa lolos dengan tawaran yang lebih kecil di babak 2 juga. Yang ini bekerja dengan baik, tetapi beberapa perubahan kecil dapat membuatnya bekerja lebih baik.
KBriggs
@KBriggs Menambahkan bot baru dengan peluang baru dan lebih baik;)
Joshua Webb
Ingin mereka berdua di sana, atau hanya 1?
KBriggs
@ KBriggs Saya tidak tahu apakah saya melewatkan tenggat waktu, tetapi saya telah menambahkan satu bot terakhir, jika saya berhasil tepat waktu, Anda dapat menghapus dua bot fraksi lainnya
Joshua Webb
1
Yap, Anda masih punya waktu
KBriggs
4

BandaidBot

BandaidBot ingin semua orang bermain bagus! Jika lawannya bagus di babak terakhir, itu akan mengorbankan dirinya untuk memberi insentif perilaku baik pada orang lain. Jika lawannya adalah putaran terakhir yang kejam, itu akan melakukan kerusakan sebanyak mungkin untuk lawannya, mengorbankan dirinya sendiri jika perlu. Tawaran sepertiga dari hp-nya jika tidak memiliki riwayat untuk bekerja. (Saya berharap bot ini akan memiliki efek riak yang menarik pada strategi lain, tidak terlalu banyak sehingga bot ini akan memiliki tingkat kemenangan yang tinggi itu sendiri. Bisa menyenangkan untuk memainkan beberapa ini)

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 akan sama baiknya dengan yang dibutuhkan untuk mengambil keuntungan dari BandaidBot. Ini akan kembali hanya di bawah sepertiga hpnya kecuali ia dapat membunuh lawannya kurang dari itu. Jika lawannya terlihat seperti BandaidBot, ia akan menawar 2, mengetahui bahwa BandaidBot akan menawar 1 karena GetAlongBot telah bergaul dengan baik dengan orang lain - kemenangan mudah selama itu benar-benar BandaidBot di ujung lainnya.

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)
Maya Sol
sumber
Ide yang sangat rapi. Saya ingin tahu seberapa besar dampaknya
KBriggs
kesalahan: return np.random.randint(history[-1], hp/2): ValueError: low >= highKasus ini perlu ditangani entah bagaimana
KBriggs
@ KBriggs harus diperbaiki sekarang!
Maya Sol
@KBriggs dimutakhirkan untuk memperbaiki pengacakan
Maya Sol
3

Bot TENful

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

Bot ini mencoba mempertahankan nilai favoritnya 10, tetapi kadang-kadang mengubah pilihannya jika diperlukan untuk memutuskan hubungan (dengan nilai favoritnya berlipat dua atau empat kali lipat) atau untuk menabung untuk putaran berikutnya, tetapi tidak dengan jumlah yang optimal karena ingin membingungkan lawan dan tidak ingin mempertimbangkan penawaran kurang dari 2 kapan saja karena diyakinkan itu jauh lebih baik daripada berharap lawan akan menawar kurang dari 1, yaitu 0.

PS: bot ini mungkin memiliki masalah strategis jika ada lebih dari 2 ^ 9 bot.

AlexRacer
sumber
Saya kira Anda tidak perlu khawatir memiliki 2 ^ 9 lawan ^ _ ^.
KBriggs
Tetapi dengan taruhan pembuka 10, dia jarang akan berhasil melewati babak pertama
KBriggs
Bot ini berpikir bahwa, jika beberapa bot benar-benar ingin memberikan lebih dari 10 hp di babak pertama, itu tidak layak untuk diperjuangkan.
AlexRacer
Haha cukup adil
KBriggs
3

CautiousBot

Pengajuan pertama ke Teka-teki Pemrograman! Menemukan tantangan Anda cukup menarik: P

Jika babak terakhir sedikit kurang dari hp, jika tidak ada riwayat bertaruh setengah hp ditambah jumlah acak kecil.

Jika riwayat memeriksa hp lawan dan jumlah putaran yang tersisa dan mencoba untuk mengalahkan lawan hp / 2 menggunakan buffer tambahan hingga sebagian kecil dari hp yang tersisa dibagi dengan jumlah putaran yang tersisa (mencoba untuk menghemat hp yang tersisa entah bagaimana untuk putaran posterior) . Periksa apakah Anda menghabiskan terlalu banyak hp (jangan bunuh diri atau menawar lebih dari yang dapat dilakukan musuh Anda).

Selalu koreksi untuk ikatan seperti bot lainnya.

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

Terlalu agresif pada putaran pertama, sekarang CautiousBot menjadi lebih berhati-hati ...

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)
Jesús Ros
sumber
Anda memiliki bug di mana ia masih memanggil randint ketika penyangga = 0: buffer_bet = np.random.randint(0, buffer) if buffer > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high. Perhatikan bahwa buffer adalah kata kunci dalam python, Anda mungkin ingin memilih nama variabel yang berbeda.
KBriggs
Oh, sepertinya buffer karena tidak selalu int - Anda mungkin membaginya dengan nol di beberapa titik. Silakan periksa logikanya dengan cermat. Saya membuatnya berjalan, tetapi Anda mungkin dapat memperbaiki kasus sudut.
KBriggs
Tangkapan bagus @KBriggs. Pikir saya memperbaikinya.
Jesús Ros
Aku masih mendapatkan error: buff_bet = np.random.randint(0, buff) if buff > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high. Tampaknya buff terkadang merupakan angka floating point antara 0 dan 1, yang mungkin akan dilemparkan ke 0 di dalam randint. Ini berfungsi jika Anda buffmemilih intsebelum panggilan
KBriggs
@ KBriggs mungkin karena ceilmengembalikan a float. Kehilangan yang satu itu ... Ty lagi: P
Jesús Ros
3

Baiklah, saya akan mencoba ini.

SnetchBot

Memeriksa fraksi kesehatan yang dialami lawan. Jika lawan telah bangkit, kalahkan dia.

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: kehilangan banyak di babak pertama, menyesuaikan batas acak belokan pertama

ambil
sumber
Tembakan pertama yang cukup bagus, skor masuk yang masuk
KBriggs
@ KBriggs Diedit sedikit (hanya putaran acak babak pertama). Meskipun saya sudah terkejut dengan menjadi setinggi tempat ke-10. Jika yang ini lebih buruk, saya akan kembali ke yang pertama: D
snetch
Anda memeras sedikit lebih banyak darinya
KBriggs
3

SquareUpBot

Sepertinya tidak banyak bot bermain dengan kekuatan alih-alih fraksi, jadi saya memutuskan untuk membuatnya, dengan beberapa optimisasi standar dan melihat di mana saya akan menempatkan. Cukup sederhana.

Juga mencoba menentukan apakah bot musuh tidak mencoba menggunakan fraksi konstan, karena fraksi kekuatan > .

EDIT: Saya dummy dan detektor fraksi saya tidak bisa bekerja. Diperbaiki sekarang.

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
Debu berlian
sumber
Bukan pukulan pertama yang buruk, skor telah diperbarui
KBriggs
@ KBriggs Saya telah memperbarui bot sehingga detektor fraksi benar-benar berfungsi.
Debu Intan