อันดับสุดท้าย

+ ---------------------------------- + --------- + ---- ----- + --------- + + ----------------------------
| ชื่อ | คะแนน | WinRate | TieRate | ความน่าจะเป็นกำจัด
+ ---------------------------------- + --------- + ---- ----- + --------- + + ----------------------------
| 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. การคำนวณบอต | 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. เปอร์เซ็นต์ 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. ค่าเฉลี่ยบอต | 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]% |
+ ---------------------------------- + --------- + ---- ----- + --------- + + ----------------------------

ขอบคุณสำหรับทุกคนที่เข้าร่วมและขอแสดงความยินดีกับ @Sarcoma สำหรับผู้ชนะ!

กฎ:

ทุกคนเริ่มต้นด้วย 100 แรงม้า ในแต่ละรอบผู้เล่น 2 คนจะถูกสุ่มเลือกจากกลุ่มผู้แข่งขันที่ยังไม่ได้เข้าแข่งขันในรอบนั้น ผู้เล่นทั้งสองเลือกหมายเลขระหว่าง 0 ถึง hp ปัจจุบันและเปิดเผยตัวเลขเหล่านั้นในเวลาเดียวกัน ผู้เล่นที่เลือกหมายเลขที่ต่ำกว่าตายทันที ผู้เล่นคนอื่นลบจำนวนที่เลือกจาก hp ที่เหลืออยู่และไปยังรอบต่อไป

การแข่งขันใช้งานได้เช่นนี้:

จากวงเล็บของผู้แข่งขัน 2 คนจะถูกสุ่มเลือก พวกเขาเผชิญหน้าและตายหนึ่งหรือทั้งสอง ผู้เล่นเสียชีวิตถ้า:

1. พวกเขาเลือกหมายเลขที่เล็กกว่าของฝ่ายตรงข้าม
2. แรงม้าของพวกเขาลดลงถึงหรือต่ำกว่าศูนย์
3. พวกเขาผูกสามครั้งติดต่อกัน

ในกรณีของความสัมพันธ์ผู้เล่นทั้งสองจะสร้างหมายเลขใหม่ได้สูงสุด 3 ครั้ง หลังจากการเผชิญหน้าผู้รอดชีวิต (ถ้ามี) จะถูกย้ายไปที่สระว่ายน้ำสำหรับรอบต่อไปและกระบวนการจะทำซ้ำจนกว่าเราจะหมดรอบสระปัจจุบัน หากมีจำนวนคี่ในพูลแล้วเลขคี่นั้นจะถูกย้ายไปยังรอบถัดไปได้ฟรี

งานของคุณคือการเขียนฟังก์ชั่นในpython2.7ซึ่งใช้เป็นอินพุตของคุณในปัจจุบันhpรายการการเสนอราคาของคู่ต่อสู้ของคุณhistoryและจำนวนเต็มtiesซึ่งจะบอกคุณว่าคุณผูกติดอยู่กับคู่ต่อสู้ปัจจุบันของคุณแล้วและจำนวนเต็มที่บอกคุณว่า บอทจำนวนมากยังคงอยู่alive(รวมถึงคุณ) และจำนวนเต็มซึ่งแสดงจำนวนบอทในstartการแข่งขัน โปรดทราบว่าประวัติไม่รวมความสัมพันธ์ ฟังก์ชั่นจะต้องคืนค่าจำนวนเต็มระหว่าง 0 ถึงจำนวนแรงม้าทั้งหมดของคุณ ตัวอย่างง่ายๆสองสามตัวอย่างที่ไม่สนใจความสัมพันธ์มีดังต่อไปนี้:

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)

หากฟังก์ชั่นของคุณคืนจำนวนที่มากกว่า hp ของคุณมันจะถูกรีเซ็ตเป็น 0 ใช่มันเป็นไปได้ที่จะฆ่าตัวตาย ฟังก์ชันของคุณต้องไม่พยายามเข้าถึงหรือแก้ไขสมาชิกของวัตถุใด ๆ ของคลาส RouletteBot คุณไม่ได้รับอนุญาตให้ดำเนินการใด ๆ ที่ระบุคู่ต่อสู้ของคุณได้อย่างชัดเจนโดยไม่คำนึงถึงบ็อตเพิ่มเติมในอนาคต การตรวจสอบสแต็กได้รับอนุญาตตราบเท่าที่เป็นไปได้ในทางทฤษฎีว่าฝ่ายตรงข้ามที่แตกต่างกันสามารถสร้างข้อมูลที่คุณได้รับจากมันได้แม้ว่าจะมีเพียงบอทเดียวเท่านั้นที่สามารถทำได้ คือคุณไม่สามารถอ่านผ่านสแต็คเพื่อดูว่ามีการเรียกใช้ฟังก์ชันของศัตรูใด

ภายใต้กฎเหล่านี้มีความเป็นไปได้ที่จะไม่มีผู้ชนะและผู้เข้าแข่งขันสองคนสุดท้ายจะฆ่ากันเอง ในกรณีนั้นผู้เข้ารอบสุดท้ายทั้งสองคนจะได้รับแต้มละครึ่ง

นี่เป็นความพยายามครั้งแรกในการเขียนโปรแกรมปริศนาของฉันดังนั้นยินดีต้อนรับคำวิจารณ์!

ควบคุมสามารถพบได้ที่นี่

BinaryBot

มีใครทำสิ่งนี้หรือยัง เดิมพันครึ่งสุขภาพของมันทุกรอบพื้น

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

SarcomaBot

หากการรบครั้งสุดท้ายประมูล hp - 1 ถ้าเป็นรอบการประมูลแรก hp ครึ่งบวกบวกจำนวนสุ่มเพิ่มเติมถึงหนึ่งในสี่ของแรงม้า ถ้ามันสามารถเอาชนะคู่ต่อสู้เอาการเสนอราคาทันทีหลังจากฝ่ายตรงข้ามประมูล hp + 1 ถ้ามันมีสุขภาพที่ต่ำกว่าคู่ต่อสู้เสนอราคาแบบสุ่มระหว่าง 75% และเป็น hp ปัจจุบัน - 1

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

SarcomaBotMk2

การปรับแต่งเล็กน้อยพยายามลดค่าใช้จ่ายในชีวิต

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

อัปเดต 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

รายการสุดท้าย

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

อัปเดต
การป้องกัน AntiAntiUpYoursBot ที่เพิ่มเข้ามา

อัปเดต
AntiAnitAntiAntiUpYours เพราะฉันแพ้

UpYours

การมาสายฉันใช้เวลาสักพักเพื่อชื่นชมบอตที่มีอยู่ใช้เวลาซักพักความคิดของคุณจากนั้นก็ทำให้พวกเขาเข้าใจผิด จากนั้นก็มาหาฉัน

คัดลอกศิลปินที่ดีศิลปินที่ดีขโมย - Pablo Picasso Me

"อัพของคุณ" เพราะฉันขโมยโดยไม่สะทกสะท้าน

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

แต่สำหรับตัวจริงนี่คือการแข่งขันที่ยอดเยี่ยม ฉันรักชุมชนนี้ในวันนี้

กองบินกล้าตาย

ทำไมต้องกังวลกับตรรกะที่ซับซ้อนเมื่อเราทุกคนกำลังจะตายต่อไป ...

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

นัดเดียว

มันจะมีชีวิตรอดอย่างน้อยหนึ่งรอบหากไม่พบกามิกาเซ่

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

Pathetic Bot ได้รับการอัพเกรดที่จำเป็นมาก:

ความพยายามที่น่าสมเพชที่บอทที่พยายามรวมคุณสมบัติของบอทอื่น ๆ

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

บอทนี้รวมเอาคุณสมบัติจาก Survivalist Bot และ Geometric Bot สำหรับการลบบ็อตที่มีประสิทธิภาพมากขึ้น

Pre-อัพเกรด:

ความพยายามที่น่าสมเพชที่บอทที่วิเคราะห์ประวัติของฝ่ายตรงข้าม

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

หากมีประวัติก่อนหน้านี้ของฝ่ายตรงข้ามแล้วมันจะคำนวณแรงม้าของฝ่ายตรงข้าม จากนั้นทำอย่างใดอย่างหนึ่งต่อไปนี้:

• หากฝ่ายตรงข้ามเป็นคู่ต่อสู้คนสุดท้ายที่มีชีวิตอยู่มันจะเสนอราคาต่ำกว่า hp
• หากฝ่ายตรงข้ามไม่ใช่ฝ่ายตรงข้ามคนสุดท้ายที่ยังมีชีวิตอยู่ แต่ฝ่ายตรงข้ามมีน้อยกว่า 16 hp มันจะมีค่าสูงกว่า hp ของฝ่ายตรงข้าม
• หากฝ่ายตรงข้ามไม่ใช่ฝ่ายตรงข้ามคนสุดท้ายที่ยังมีชีวิตอยู่และมีประวัติของความสัมพันธ์มันก็จะเสนอราคาแรงม้าเพราะเบื่อหน่ายกับความสัมพันธ์
• มิเช่นนั้นมันจะประมูสสูงกว่าคู่ต่อสู้

หากไม่มีประวัติก็จะทำการคำนวณแฟนซีที่ฉันแฮ็กด้วยกันและเสนอราคานั้น หากค่าเกิน 100 จะเป็นการเสนอราคาโดยอัตโนมัติลบด้วย 1

ฉันแฮ็ครหัสนี้ด้วยกันในระหว่างการทำงานและนี่คือการส่งครั้งแรกของฉันดังนั้นมันอาจจะไม่ชนะหรืออะไรก็ได้และมันจะแพ้กามิกาเซ่

แก้ไข: เนื่องจากข้อเสนอแนะบางอย่างพฤติกรรมการเริ่มต้นของบอทจึงเปลี่ยนไปเพื่อเสนอราคาที่สูงขึ้น

แก้ไข 2: เพิ่มพารามิเตอร์เริ่มต้นที่ไม่ทำอะไรเลย

แก้ไข 3: เพิ่ม bot spinoff ใหม่:

[ความพยายามอย่างน่าสมเพชที่บอทที่โจมตีบอทบ็อต

[บ็อตนี้วิเคราะห์ว่าฝ่ายตรงข้ามเป็นนักเลงหรือไม่และแสร้งเป็นหนึ่งเช่นกันเพื่อรับการเสนอราคาต่ำสุดหวานที่สามารถทรัมป์ได้อย่างง่ายดาย]

บอทนี้ถูกทำลายโปรดลบออกจากกระดานผู้นำ

แก้ไข 4: แก้ไขข้อผิดพลาดเปลี่ยนคุณสมบัติการผูก

บอทเตะ

ตัวเลือกเสียงสำหรับคู่ต่อสู้ของฉันคือการเสนอราคาครึ่งหนึ่งของชีวิตของเขา จากนั้นเราเสนอราคาสูงถึงครึ่งหนึ่งของชีวิตของเขา + 1 หากเราไม่สามารถพาเขาออกไปด้วยการเสนอราคาที่ดีนั่นคือราคาเสนอที่เล็กกว่าครึ่งหนึ่งของชีวิตของเรา

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

บอทเตะเห็นได้ชัดว่าเป็นตัวซวยของหมัดบอท!

บอทเตะหมายถึง

KickBot ใหม่นี้เริ่มนิ่มกว่าในรอบแรกเพื่อให้เขาสามารถเตะได้ยากขึ้นในรอบต่อไปนั่นคือค่าเฉลี่ย!

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 เตะปรีชาญาณ

พี่ชายทั้งสองของเขาต้องฆ่าตัวตาย แต่ WiseKickBot เรียนรู้จากการตกของเขา

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

น้ำตกตาด

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)

ความพยายามในการเทียบเท่า ธ ปท. สำหรับตาด สมมติว่าการเดิมพันส่วนใหญ่มีค่าประมาณเท่ากันระหว่างรอบ การใช้สมมติฐานนั้นจะพยายามเอาชนะบอทศัตรูในขณะที่ค่อนข้างประหยัด ใช้เวลาประมาณ 40 สุขภาพในการเปิดรอบ

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

วิธีแก้ปัญหาสำหรับการป้องกันการต่อต้าน UpYours ของ SarcomaBot คือการใช้โค้ดส่วนใหญ่สำหรับการใช้งานของฉันเอง! หรือฉันจะใช้รหัสของ UpYoursBot? คำถามที่ต้องไตร่ตรองในขณะที่คุณอ่านบอทของฉัน ...

AntiAntiUpYours Bot ได้พัฒนาเป็น AntiAntiAntiUpYours 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) 

โพลีบอททำการถดถอยพหุนามในประวัติของบอทของคุณและชนะคะแนนที่คาดการณ์ไว้เล็กน้อย

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)

บอทดีงามมีช่วงเวลาที่ดี แต่ตัดสินใจเข้านอนเร็ว นอนหลับสนิทบอทที่ดีงาม

1/2 Punch 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 หมัด Bot ได้รังแกมากเกินไปและแม้กระทั่งกลายเป็นขี้ข้าไป UpYoursBot ที่เพื่อให้พี่ชายของเขาที่StrikerBotมาเพื่อช่วยให้

ไม่แตกต่างกันมากจากการเพิ่มประสิทธิภาพ 1/2 Punch แต่เขาค่อนข้างฉลาดและทำได้ดีในการวิ่งที่ฉันทำ (10k และ 35k แม้ว่าเขาอาจแพ้ KickbanBot)

รุ่นล่าสุดหมดเวลาหมดแล้ว เว้นแต่จะมีเหตุการณ์ประหลาดใจเกิดขึ้นมันควรจะปลอดภัยที่สองหากไม่ได้รับก่อน (มีโอกาสน้อยที่จะเอาชนะ 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

บอท

แนวคิดก็คืออาจจะมีบอทสองตัวหรือมากกว่านั้นสามารถใช้ในการจำลองเดียวกันได้ บอทพยายามที่จะให้ "ชนะง่ายๆ" กับบอตอื่น ๆ ในแก๊งค์โดยดูว่าประวัติของมันนั้นทวีคูณเป็น 7 ราคาหรือไม่ แน่นอนว่ามันสามารถจัดการกับบอตอื่น ๆ ได้อย่างง่ายดายเช่นกัน จากนั้นฉันคำนวณการเดาราคาเสนอของบ็อตที่ไม่ใช่แก๊งตามอัตราส่วนของสุขภาพของฉันต่ออัตราส่วนและสุขภาพก่อนหน้าของพวกเขาต่อการเสนอราคาก่อนหน้าและเพิ่ม 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

กรณีที่เลวร้ายที่สุด

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

บอทง่าย ๆ ผลตอบแทนhp - hp / (start - alive + 4)สำหรับกรณีส่วนใหญ่และในกรณีของความสัมพันธ์ที่เพิ่มขึ้นได้โดย 2 (ต้องหนึ่งขึ้น!) 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)

บอทจะพยายามเสนอราคาสูงกว่าคู่แข่งสามารถเสนอราคาได้ถ้าเป็นไปได้

ธ ปท

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

ตัดสินใจเกี่ยวกับสุขภาพที่ควรเสียสละโดยพิจารณาจากจำนวนบอทที่เหลืออยู่ หากเหลือเพียงบอทสองตัวมันจะเสนอราคาhp-1แต่ถ้าเหลืออีกสามมันจะบิตครึ่งนั้นสี่ซ้ายหนึ่งในสาม ฯลฯ

อย่างไรก็ตามในการแข่งขันที่มีขนาดใหญ่มากฉันคิดว่าฉันจะต้องเสนอราคามากกว่า 3 หรือ 4 แรงม้าเพื่อหลีกเลี่ยงการเสียชีวิตในรอบแรกดังนั้นฉันจึงวางขอบเขตไว้ที่ 10 แน่นอนฉันยังคงไม่เสนอราคามากขึ้น hp-1กว่า

นอกจากนี้ยังเพิ่ม 1.5 hp สำหรับความสัมพันธ์เนื่องจากฉันเห็นบ็อต "เพิ่ม 1 hp สำหรับความสัมพันธ์" หลายรายการ ฉันไม่แน่ใจว่าสิ่งนั้นนับว่าเป็นการโกงหรือไม่ ถ้าเป็นเช่นนั้นฉันจะเปลี่ยนมัน

ความคิดที่ดีโดยวิธี!

Spitball Bot 2.0

มีอะไรใหม่

• เปลี่ยนเป็นการหารด้วยจำนวนรอบที่เหลือแทนจำนวนของบ็อตที่เหลือ (ขอบคุณ @Heiteira!) อันที่จริงตอนนี้ฉันหารด้วยจำนวนที่ยกกำลัง.8เพื่อให้โหลดราคาเสนอของฉันเพิ่มขึ้นอีกนิด

• เพิ่มราคาเสนอขั้นต่ำจาก 10 เป็น 20 (ขอบคุณ @KBriggs!)

• แทรกการตรวจสอบว่าการเสนอราคา spitball มากกว่า HP ปัจจุบันของคู่ต่อสู้หรือไม่และลดให้ต่ำลงถ้าเป็น

(ดังนั้นจะไม่แสดงรหัสด้านล่างเป็นรหัสยกเว้นว่าฉันใส่ข้อความไว้ที่นี่ดังนั้นตกลง)

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

ทางเรขาคณิต

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)

บอต 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

พยายามให้ได้มากที่สุดด้วยความพยายามอย่างน้อยที่สุด:

• ถ้าเราสามารถชนะเพียงแค่ทำมัน
• ถ้ามันเป็นรอบสุดท้ายอย่าพยายามตาย
• มิฉะนั้นก็ไม่ต้องกังวล

ทำไม?

พยายามใช้ประโยชน์จากความน่าจะเป็น: การชนะรอบแรกโดยการเล่นต่ำเป็นวิธีที่ดีที่สุดในการเริ่มการแข่งขัน 13 ดูเหมือนจะเป็นจุดที่น่าสนใจ: รอบที่สองเป็นชัยชนะที่แน่นอนและส่วนที่เหลือคือ Spaziergang ในสวน

เดาบอท

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)

โพสต์ครั้งแรกที่นี่ มันดูสนุกมากดังนั้นฉันจึงพยายามอย่างยิ่งยวดและคาดเดาว่าบอทอื่นจะเดิมพันอย่างไร

แก้ไข 1: เพิ่มอีก 1 ในการเดิมพันครั้งแรกเพียงเพื่อลดโอกาสของการเสมอกันกับผู้อื่นเดิมพัน 51

แก้ไข 2: การเปิดตัวของบ็อต Stole Sarcoma เนื่องจากมีโอกาสดีที่จะไม่ถูกกำจัดออกไปก่อนเสมอ

แก้ไข 3: Bot รอดชีวิตได้ดีมากในรอบแรก แต่มันถูกทำลายได้ง่ายในระยะต่อมา เปลี่ยนวิธีที่หุ่นยนต์คิดเกี่ยวกับรอบที่สองในขณะนี้ที่นักพนันครึ่งหนึ่งเสียชีวิตในน้ำ

แก้ไข 4: ตอนนี้รอบแรกดีฉันเปลี่ยนวิธีจัดการรอบที่สอง ตายมากในรอบที่สองดังนั้นฉันจึงต้องเอาชีวิตรอดอย่างใด

บอทเลือด

ทำให้บอกระหายน้ำกำลังมองหาการฆ่า ความคิดคือการพยายามเอาชนะบอตการพนันต่ำและเมื่อผ่านมานองเลือดในรอบแรกมันก็ควรจะหยุดไม่ได้เพราะมันควรจะมี HP จำนวนมหาศาลเพื่อต่อสู้กับศัตรู

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

เพียงแค่เสนอราคาน้อยกว่าครึ่งแรงม้า

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

ร็อบบี้รูเล็ต

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

บอทนี้ทำการวิเคราะห์อย่างง่าย ๆ เกี่ยวกับประวัติของบอทศัตรูหรือเสนอราคาครึ่งหนึ่งของพลังชีวิตที่เหลือ

เสนอราคาสูงกว่าการแข่งขันน้อยที่คุณมี ขอบคุณผู้แสดงความคิดเห็นสำหรับการแนะนำการปรับปรุง

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 และ HalvsiesBot

ขอบคุณที่ตอบคำถามของฉัน ผลลัพธ์ที่ได้คือบอทที่ซับซ้อนมากขึ้น

HalvsiesBot เป็นบอทที่แปลกใหม่ 'เพิ่งผ่านไปครึ่งทาง' มีโอกาส 50/50 ในการชนะ ฉันคิดว่า.

SurvivalistBot สร้างชุดข้อมูลต้นไม้แบบทวิภาคถ้ามีการตัดสินใจแบบอื่นบนพื้นฐานของชุดข้อมูลรวมถึงการแทนที่บนเน็คไท (ถ้ามันกระทบ 2 เสมอมันจะเป็นคามิกาเซส

หลามของฉันเป็นสนิมเล็กน้อยดังนั้นรหัสอาจเป็นบิตรถดังนั้นโปรดแก้ไขหรืออัปเดต

มันถูกสร้างขึ้นเพื่อพยายามหาบิตของข้อมูลเพื่ออนุมานสิ่งต่างๆเช่นจำนวน HP ที่เหลืออยู่จำนวนขั้นต่ำของบอทที่มีแนวโน้มที่จะต่อสู้จำนวน HP ขั้นต่ำที่จะออกจากการเสนอราคาเฉลี่ย นอกจากนี้ยังใช้การสุ่มในสถานการณ์ที่ไม่ชัดเจนเช่นการเปิดเล่นหรือปัญหาการเสนอราคาที่ดีที่สุด

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

คำนวณบอท

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)

บอทการคำนวณเชิงรุก

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)

บอทต่อต้านการเตะ

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

หากเราสามารถทำนายการกระทำของคู่ต่อสู้เราสามารถทำการเดิมพันที่ดีที่สุด! ถ้าเราลาดเท (ข้อมูลไม่เพียงพอหรือฝ่ายตรงข้ามสุ่มเกินไป) อย่างน้อยเราก็สามารถทำสิ่งที่จะเพิ่มศักยภาพในการชนะของเรา ตามหลักวิชาอย่างน้อยครึ่งหนึ่งของจำนวนบอทที่ยังมีชีวิตอยู่จะตายในแต่ละรอบ ดังนั้นฉันสามารถคาดหวังว่าจะมีรอบ log2 (ชีวิต) มากที่สุด เป็นการดีที่เราจะแบ่งแรงม้าของเราเท่า ๆ กันระหว่างรอบทั้งหมด อย่างไรก็ตามเรารู้ว่าบ็อตบางตัวจะโง่และฆ่าตัวตาย / ตายเร็วดังนั้นเราควรเดิมพันเพิ่มขึ้นเล็กน้อยในรอบก่อนหน้า

Aggressive Calculating Bot ของรหัสการคำนวณ Bot ของการแก้ไขเพื่อพยายามที่จะมีชีวิตอยู่โดยการก้าวร้าวมากขึ้นในราคาของสุขภาพในระยะยาว การจำลองเท่านั้นที่จะบอกได้ว่าจังหวะหรือค่าชนะ

Anti Kick Bot ควรเอาชนะผู้นำคนปัจจุบัน KickBot: P

แก้ไข: แทนที่ Bot ที่กำหนดได้ด้วย Anti Bot Bot บอทที่ชาญฉลาดซึ่งมีค่าตอบแทนใกล้เคียงกันเกือบทุกประการ ป้องกันการลงคะแนนมากกว่า HP ฝ่ายตรงข้ามด้วย

GenericBot

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

มันสายไปแล้ว ... ฉันเหนื่อย ... ไม่สามารถนึกชื่อได้ ... และรูปแบบของบ็อตนี้คล้ายกับคนอื่น ๆ เพียงแค่มีอัลกอริธึมที่แตกต่างกันเล็กน้อยในประวัติศาสตร์ มันพยายามที่จะให้ได้อัตราปัจจุบันที่ฝ่ายตรงข้ามพุ่งไปเล่นการพนัน ... หรืออะไรทำนองนั้น ... 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

Bot Bot [ออกจากตำแหน่ง]

จะลองและชายฝั่งมันผ่านการแข่งขันโดยแบ่งเป็นแรงม้าระหว่างรอบ จะเสนอราคาแรงม้าที่เหลือใด ๆ ในรอบแรกเพื่อให้ตัวเองมีโอกาสที่ดีกว่าในการทำรอบ "ตามชายฝั่ง"

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

เนื่องจากฉันชอบความท้าทายนี้มากฉันจึงต้องทำบอทใหม่ รุ่นนี้เสียสละบางส่วนของมันเป็นแรงม้าในภายหลังโดยใช้แรงม้ามากขึ้นในสองรอบแรก

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

ธ ปท

พยายามคำนวณเปอร์เซ็นต์เฉลี่ยที่ hp ใช้กับคู่ต่อสู้และราคาเสนอตามนั้น

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

เดิมพันจำนวนเท่ากันในแต่ละรอบ มันไม่น่าจะอยู่รอดในรอบแรก แต่ถ้าโชคดีพอที่จะไปให้ถึงที่สุด

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

Bot Kickban

บอทนี้พยายามที่จะต่อต้านผู้นำในปัจจุบัน Mean Kickbot โดยการตบมันในรอบที่หนึ่งและเล่นมากขึ้นเรื่อย ๆ หลังจากนั้นถ้าจำได้

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)

บอทสามในสี่

เขาจะไม่เอาชนะ MehBot หรือ SarcomaBot แต่ฉันคิดว่าเขาทำได้ดี เมื่อฉันเห็นการท้าทายเป็นครั้งแรกนี่เป็นสิ่งแรกที่โผล่ขึ้นมาในใจฉันเสมอ * เดิมพันสุขภาพของคุณสามในสี่ยกเว้นว่าไม่มีเหตุผล

* หลังจากบอลต่ำรอบแรก

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

บอทที่เจ็ด

หลังจากความสำเร็จปานกลางของบอท 3/4 มีเศษใหม่ในเมืองมันเป็นเพียงเหตุผล

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

เศษส่วนที่สมบูรณ์แบบ

ฉันทั้งหมด

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 ต้องการให้ทุกคนเล่นได้ดี! หากคู่ต่อสู้ของตนดีในรอบสุดท้ายมันจะเสียสละตัวเองเพื่อจูงใจพฤติกรรมที่ดีในผู้อื่น หากฝ่ายตรงข้ามถูกหมายถึงรอบสุดท้ายมันจะสร้างความเสียหายมากที่สุดเท่าที่จะเป็นไปได้กับฝ่ายตรงข้ามและเสียสละตัวเองหากจำเป็น มันเสนอราคาหนึ่งในสามของแรงม้าถ้ามันไม่มีประวัติที่จะทำงานด้วย (ฉันหวังว่าบ็อตนี้จะมีระลอกคลื่นที่น่าสนใจในกลยุทธ์อื่น ๆ ไม่มากจนบอทนี้จะมีอัตราการชนะสูงในตัวมันคงสนุกที่ได้เล่นสองสามอย่างนี้)

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 มันจะกลับมาต่ำกว่าหนึ่งในสามของแรงม้าของมันเว้นแต่ว่ามันจะสามารถฆ่าคู่ต่อสู้ได้น้อยกว่านั้น หากฝ่ายตรงข้ามดูเหมือน BandaidBot มันจะประมูล 2 โดยรู้ว่า BandaidBot จะเสนอราคา 1 เพราะ GetAlongBot เข้ากันได้ดีกับคนอื่น - ชนะง่ายตราบใดที่ BandaidBot ชนะจริง ๆ

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)

บอทที่แข็งแกร่ง

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

บอทนี้พยายามที่จะยึดค่าที่ชื่นชอบเป็น 10 แต่จะเปลี่ยนทางเลือกเป็นบางครั้งหากจำเป็นต้องทำลายการผูก (ด้วยค่าที่ชื่นชอบเป็นสองเท่าหรือสี่เท่า) หรือเพื่อประหยัดรอบต่อไปในอนาคต แต่ไม่ใช่ด้วยจำนวนที่เหมาะสม ฝ่ายตรงข้ามและไม่ต้องการพิจารณาการเสนอราคาน้อยกว่า 2 ตลอดเวลาเนื่องจากเชื่อว่าดีกว่าหวังว่าฝ่ายตรงข้ามจะประมูลน้อยกว่า 1 นั่นคือ 0

PS: บ็อตนี้อาจมีปัญหาเชิงกลยุทธ์หากมีมากกว่า 2 ^ 9 บอท

CautiousBot

ส่งครั้งแรกเพื่อการเขียนโปรแกรมปริศนาที่เคย! พบกับความท้าทายที่น่าสนใจ:

หากรอบสุดท้ายบิตน้อยกว่าหนึ่งแรงม้าถ้าไม่มีประวัติเดิมพันครึ่งแรงม้าบวกกับจำนวนสุ่มขนาดเล็ก

หากตรวจสอบประวัติ hp คู่ต่อสู้และจำนวนรอบที่เหลือและพยายามชิงคู่ต่อสู้ hp / 2 โดยใช้บัฟเฟอร์เพิ่มเติมถึงเศษส่วนของ hp ที่เหลือหารด้วยจำนวนรอบที่เหลือ . ตรวจสอบว่าคุณใช้แรงม้ามากเกินไปหรือไม่ (อย่าฆ่าตัวเองหรือเสนอราคามากกว่าศัตรูของคุณ)

แก้ไขความสัมพันธ์เสมอเหมือนบอทอื่น ๆ

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

ก้าวร้าวมากเกินไปในรอบแรกตอนนี้ CautiousBot ได้รับความระมัดระวังมากยิ่งขึ้น ...

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)

เอาล่ะฉันจะลองทำดู

SnetchBot

ตรวจสอบเศษส่วนของสุขภาพที่ฝ่ายตรงข้ามได้ไปด้วย หากฝ่ายตรงข้ามยกขึ้นเอาชนะเขาได้

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

แก้ไข: แพ้มากในรอบแรกปรับการ จำกัด การหมุนครั้งแรก

SquareUpBot

ดูเหมือนจะไม่บอทจำนวนมากกำลังเล่นกับพลังแทนเศษส่วนดังนั้นฉันตัดสินใจที่จะทำอย่างใดอย่างหนึ่งด้วยการเพิ่มประสิทธิภาพมาตรฐานบางอย่างและดูว่าฉันจะวางที่ไหน ค่อนข้างง่าย

ยังพยายามที่จะตรวจสอบว่าการ ธ ปทศัตรูไม่พยายามที่จะใช้บางส่วนอย่างต่อเนื่องเพราะอำนาจ > เศษส่วน

แก้ไข: ฉันเป็นคนโง่และเครื่องตรวจจับเศษส่วนของฉันไม่สามารถทำงานได้ ซ่อมแซมแล้ว

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