Bảng xếp hạng cuối cùng

+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| Tên | Điểm | WinRate | Cà vạt | Xác suất loại bỏ |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +
| 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. Tiền đạo | 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. HardCodingBot | 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,02394 | 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. Thận trọngBot | 0,01629 | 1,56% | 0,14% | [15 41 27 11 4 1]% |
| 26. Bờ biểnBotV2 | 0,01113 | 1,40% | 0,02% | [83 12 3 1 0 0]% |
| 27. Tính toánBot | 0,01404 | 1,29% | 0,22% | [87 9 1 1 1 1]% |
| 28. HalfPunchBot | 0,0141 | 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. Hình họcBot | 0,00776 | 0,74% | 0,07% | [19 46 25 7 2 1]% |
| 32. Đoán | 0,00719 | 0,05% | 1,34% | [65 17 4 6 5 3]% |
| 33. Bị ràng buộcRandomBot | 0,00622 | 0,60% | 0,05% | [42 39 12 5 2 0]% |
| 34. Máy rải 0,00549 | 0,54% | 0,02% | [32 43 19 4 1 0]% |
| 35. Xác định | 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,0037 | 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. TENkishBot | 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. Ag xâmiveBoundedRandomBotV2 | 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. Bệnh hoạn | 0,00016 | 0,01% | 0,02% | [94 0 5 1 0 0]% |
| 51. OverfitedBot | 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]% |
+ ---------------------------------- + --------- + ---- ----- + --------- + ---------------------------- +

Cảm ơn tất cả mọi người đã tham gia và chúc mừng @Sarcoma đã giành chiến thắng!

Quy tắc:

Mọi người bắt đầu với 100 hp. Mỗi vòng, 2 người chơi được chọn ngẫu nhiên từ nhóm thí sinh chưa tham gia vòng thi đó. Cả hai người chơi chọn một số từ 0 đến hp hiện tại của họ và tiết lộ những số đó cùng một lúc. Người chơi chọn số thấp hơn ngay lập tức chết. Người chơi khác trừ số đã chọn của họ từ hp còn lại của họ và đi tiếp vào vòng tiếp theo.

Giải đấu hoạt động như thế này:

Từ khung của thí sinh, 2 được chọn ngẫu nhiên. Họ đối mặt và một hoặc cả hai đều chết. Một người chơi chết nếu:

1. Họ chọn một số nhỏ hơn so với đối thủ của họ
2. HP của họ giảm xuống hoặc dưới 0
3. Họ buộc ba lần liên tiếp với đối thủ của họ

Trong trường hợp quan hệ, cả hai người chơi chỉ cần tạo số mới, tối đa 3 lần. Sau cuộc đối mặt, người sống sót (nếu có) được chuyển đến bể bơi cho vòng tiếp theo, và quá trình lặp lại cho đến khi chúng ta cạn kiệt bể tròn hiện tại. Nếu có một số lẻ trong nhóm, thì số lẻ đó sẽ chuyển sang vòng tiếp theo miễn phí.

Nhiệm vụ của bạn là viết một hàm trong python2.7 , lấy đầu vào hiện tại của bạn hp, danh sách giá thầu của đối thủ historyvà một số nguyên tiescho bạn biết bạn đã liên kết với đối thủ hiện tại bao nhiêu lần và một số nguyên cho bạn biết nhiều bot vẫn còn alive(bao gồm cả bạn) và một số nguyên liệt kê số lượng bot tại startgiải đấu. Lưu ý rằng lịch sử không bao gồm các mối quan hệ. Hàm phải trả về một số nguyên từ 0 đến tổng hp hiện tại của bạn. Một vài ví dụ đơn giản, bỏ qua các mối quan hệ, được hiển thị dưới đây:

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)

Nếu chức năng của bạn trả về một số lớn hơn hp của bạn, nó sẽ được đặt lại về 0. Có, có thể tự sát. Chức năng của bạn không được cố gắng truy cập hoặc sửa đổi bất kỳ thành viên của bất kỳ đối tượng nào của lớp RouletteBot. Bạn không được phép thực hiện bất kỳ hành động nào xác định rõ ràng đối thủ của bạn bất kể các bot bổ sung trong tương lai. Việc kiểm tra ngăn xếp được cho phép miễn là về mặt lý thuyết có thể có nhiều hơn một đối thủ khác biệt có thể tạo ra thông tin mà bạn lượm lặt được từ nó, ngay cả khi chỉ có một bot hiện có. tức là, bạn không thể chỉ đọc qua ngăn xếp để xem hàm kẻ thù nào được gọi.

Theo các quy tắc này, có thể không có người chiến thắng và hai thí sinh cuối cùng giết nhau. Trong trường hợp đó cả hai người vào chung kết nhận được một nửa điểm mỗi.

Đây là nỗ lực giải đố lập trình đầu tiên của tôi, vì vậy các nhà phê bình đều được chào đón!

Bộ điều khiển có thể được tìm thấy ở đây .

Nhị phân

Đã có ai làm xong cái này chưa? Đặt cược một nửa sức khỏe của nó mỗi vòng trôi nổi.

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

Sarcoma

Nếu trận đấu cuối cùng đấu giá hp - 1. Nếu đó là trận đấu đầu tiên đấu thầu một nửa hp cộng với số tiền ngẫu nhiên bổ sung lên đến một phần tư hp. Nếu nó có thể đánh bại đối thủ hoàn toàn trả giá sau giá thầu đó đối thủ hp + 1. Nếu nó có sức khỏe thấp hơn giá thầu ngẫu nhiên của đối thủ trong khoảng 75% và đó là hp hiện tại - 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

Tinh chỉnh nhỏ cố gắng để giảm chi tiêu cuộc sống.

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

Cập nhật Tinh chỉnh

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

Nhập cảnh cuối cùng

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

Cập nhật
bảo vệ UpYoursBot được thêm

Cập nhật
bảo vệ AntiAntiUpYoursBot được thêm

Cập nhật
AntiAnitAntiAntiUpYoursBot Tôi bị đánh bại

Lên

Đi muộn là tôi đã dành một chút thời gian để chiêm ngưỡng các bot hiện có, dành một chút thời gian để thay đổi ý tưởng của các bạn, sau đó không làm phiền chúng. Rồi nó đến với tôi.

Nghệ sĩ giỏi sao chép, nghệ sĩ vĩ đại ăn cắp. - Pablo Picasso nhớ

"Up Yours" vì tôi ăn cắp một cách bừa bãi (và đôi khi giải quyết một hoặc hai điểm vào giá thầu của bot của bạn để tăng một lần cho họ).

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

Nhưng thực tế, đây là một kẻ cạnh tranh tuyệt vời. Tôi yêu cộng đồng này vào những ngày như thế này.

Kamikaze

Tại sao phải bận tâm với logic phức tạp khi tất cả chúng ta sẽ chết ...

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

Một Châu

Nó sẽ tồn tại ít nhất một vòng nếu nó không gặp phải kamikaze.

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

Bot thảm hại được nâng cấp rất cần thiết:

Nỗ lực thảm hại tại một bot cố gắng kết hợp các tính năng của các bot khác

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 này kết hợp các tính năng từ Survivalist Bot và hình học Bot cho các cuộc triệt phá bot hiệu quả hơn.

Nâng cấp trước:

Nỗ lực thảm hại tại một bot phân tích lịch sử của đối thủ

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

Nếu có lịch sử trước đó của đối thủ, thì nó sẽ tính hp của đối thủ. Sau đó, nó thực hiện một trong những điều sau đây:

• Nếu đối thủ của nó là đối thủ cuối cùng còn sống, thì nó sẽ trả giá thấp hơn một lần so với hp của nó.
• Nếu đối thủ của nó không phải là đối thủ cuối cùng còn sống nhưng đối thủ có ít hơn 16 mã lực, thì nó sẽ trả giá cao hơn hp của đối thủ.
• Nếu đối thủ của nó không phải là đối thủ cuối cùng còn sống và có một lịch sử các mối quan hệ, thì nó sẽ trả giá hp của nó vì nó chán các mối quan hệ.
• Nếu không, nó sẽ trả giá cao hơn đối thủ của mình.

Nếu không có lịch sử, thì nó sẽ thực hiện một số tính toán ưa thích mà tôi đã hack cùng nhau và trả giá đó. Nếu giá trị vượt quá 100, thì nó sẽ tự động trả giá hp trừ đi 1.

Tôi đã hack mã này cùng nhau trong khi làm việc và đây là lần gửi đầu tiên của tôi, vì vậy nó có thể sẽ không thắng hoặc bất cứ điều gì, và nó sẽ thua kamikaze.

EDIT: Do một số đề xuất, hành vi bắt đầu của bot đã được thay đổi để đặt giá trị cao hơn.

EDIT 2: thêm param bắt đầu mà không làm gì

EDIT 3: Đã thêm bot spinoff mới:

[Nỗ lực thảm hại tại một bot tấn công Gang Bots (cũng như làm mọi thứ mà bot trên làm)] XÓA

[Bot này phân tích xem đối thủ của nó có phải là gangbot hay không và giả vờ là một để có được giá thầu thấp ngọt mà nó có thể dễ dàng vượt qua.]

Bot này đã bị loại bỏ, xin vui lòng xóa nó khỏi bảng xếp hạng.

EDIT 4: Đã sửa lỗi, thay đổi tính năng tie.

Đá Bot

Sự lựa chọn âm thanh cho đối thủ của tôi là trả giá một nửa cuộc đời. Sau đó, chúng tôi trả giá tới một nửa cuộc đời của anh ấy + 1 nếu chúng tôi không thể đưa anh ấy ra ngoài với giá thầu âm thanh, đó là giá thầu nhỏ hơn một nửa cuộc sống của chúng tôi.

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 bot rõ ràng là kẻ thù của bot punch!

Kick Kick có nghĩa là

KickBot mới này đá nhẹ hơn ở vòng đầu tiên chỉ để anh ta có thể đá mạnh hơn vào các vòng tiếp theo, điều đó có nghĩa là!

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 khôn ngoan

Cả hai anh trai của anh đã phải tự sát nhưng WiseKickBot đã học được từ những người đã ngã xuống.

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

Tất cả 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)

Một nỗ lực tương đương với một bot ăn miếng trả miếng. Giả sử hầu hết các cược là gần như nhau giữa các vòng. Sử dụng giả định đó, nó cố gắng đánh bại bot kẻ thù trong khi vẫn khá đạm bạc. Dành khoảng 40 sức khỏe cho vòng khai mạc.

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

Một cách giải quyết để bảo vệ chống UpYours của SarcomaBot, đặt biệt danh hầu hết mã của họ cho mục đích sử dụng của riêng tôi! Hay tôi đang lấy mã của UpYoursBot? Một câu hỏi để suy ngẫm trong khi bạn đọc qua bot của tôi ...

Bot AntiAntiUpYours đã phát triển để trở thành Bot AntiAntiAntiAntiUpYours! Bây giờ với nhiều bản vá khỉ.

Nhiều bot

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

Poly bot thực hiện hồi quy đa thức trong lịch sử bot của bạn và đánh bại số điểm dự đoán bằng một lượng nhỏ.

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)

Classy bot đã có một thời gian tốt, nhưng đã quyết định đi ngủ sớm. Ngủ ngon, bot đẳng cấp.

1/2 cú đấm Bot, xem lại

Tôi nghĩ rằng nó sẽ chết khá nhanh. Đáng giá Đổi tên chức năng, quên thay đổi tên ở đó.

Phiên bản được xem lại đã sẵn sàng, cơ hội chiến thắng cao hơn (thậm chí nhiều hơn ở vòng cuối cùng) và bảo vệ nhẹ khỏi các bot nhóm

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

Tiền đạo Bot

1/2 Punch Bot đã bị bắt nạt quá nhiều và thậm chí trở thành một kẻ lừa đảo cho UpYoursBot để anh trai của anh ta, StrikerBot , đến giúp đỡ.

Không có nhiều khác biệt so với 1/2 Punch được tối ưu hóa nhưng anh ấy thông minh hơn một chút và đã làm tốt trong các lần chạy tôi đã làm (10k và 35k, mặc dù anh ấy có thể thua KickbanBot)

Phiên bản cuối cùng, thời gian đã hết. Trừ khi một số bất ngờ tăng lên, nó sẽ đảm bảo vị trí thứ hai, nếu không giành được vị trí thứ nhất (có cơ hội mỏng để đánh bại 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

Gang Bot

Ý tưởng là có khả năng hai hoặc nhiều bot có thể được sử dụng trong cùng một mô phỏng. Bot cố gắng đưa ra "chiến thắng dễ dàng" cho các bot khác trong băng đảng, bằng cách xem liệu lịch sử của nó có bội số của 7 giá thầu hay không. Tất nhiên, điều này cũng có thể dễ dàng bị thao túng bởi các bot khác. Sau đó, tôi tính toán dự đoán về giá thầu của các bot không thuộc băng nhóm dựa trên tỷ lệ sức khỏe của tôi với tỷ lệ sức khỏe trước đó của chúng so với giá thầu trước đó và thêm 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

Trường hợp xấu nhất

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

Bot đơn giản. Trả về hp - hp / (start - alive + 4)cho hầu hết các trường hợp và trong trường hợp cà vạt tăng nó lên 2 (phải tăng một lần!) Cho mỗi cà vạt, đảm bảo không trả lại số trên số đó hp.

Trả giá cao hơn

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 sẽ cố gắng trả giá cao hơn đối thủ có thể trả giá nếu có thể.

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

Đưa ra đánh giá về mức độ hy sinh của nó dựa trên số lượng bot còn lại. Nếu chỉ còn hai bot, nó sẽ trả giá hp-1, nhưng nếu có ba trái, nó sẽ giảm một nửa, bốn trái, một phần ba, v.v.

Tuy nhiên, trong một cuộc thi rất lớn, tôi cho rằng tôi sẽ phải trả giá cao hơn 3 hoặc 4 hp để tránh bị chết ở vòng đầu tiên, vì vậy tôi đã đặt giới hạn thấp hơn ở mức 10. Tất nhiên, tôi vẫn sẽ không bao giờ trả giá cao hơn hơn hp-1.

Nó cũng thêm 1,5 hp cho các mối quan hệ, vì tôi thấy một số bot "thêm 1 hp cho các mối quan hệ". Tôi không chắc chắn nếu điều đó được coi là gian lận. Nếu có, tôi sẽ thay đổi nó.

Nhân tiện, ý tưởng tuyệt vời!

Spitball Bot 2.0

Có gì mới?

• Chuyển sang chia cho số vòng còn lại thay vì số bot còn lại (Cảm ơn @Heiteira!). Trên thực tế, hiện tại tôi đang chia cho số đó được tăng sức mạnh .8, để tải trước giá thầu của tôi thêm một chút nữa.

• Đặt giá thầu tối thiểu từ 10 đến 20 (Cảm ơn @KBriggs!)

• Đã chèn kiểm tra xem giá thầu spitball có vượt qua HP hiện tại của đối thủ hay không và hạ thấp nó nếu có.

(SO sẽ không hiển thị mã dưới đây dưới dạng mã trừ khi tôi đặt văn bản ở đây, vì vậy 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

Hình học

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

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

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

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

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

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

Bot 13

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

Cố gắng tối đa hóa chiến thắng với nỗ lực ít nhất:

• nếu chúng ta có thể giành chiến thắng, chỉ cần làm điều đó
• Nếu đó là vòng cuối cùng, đừng chết vì cố gắng
• nếu không, đừng bận tâm

Tại sao?

Cố gắng tận dụng xác suất: chiến thắng vòng đầu tiên bằng cách chơi thấp là cách tốt nhất để bắt đầu giải đấu. 13 dường như là điểm ngọt ngào: vòng thứ hai là một chiến thắng chắc chắn, và phần còn lại là một Spaziergang trong công viên.

Đoán 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)

Lần đầu tiên đăng ở đây. Điều này trông giống như rất nhiều niềm vui vì vậy tôi đang gửi nỗ lực vượt quá kinh khủng của mình và đoán xem các bot khác sẽ đặt cược gì.

Chỉnh sửa 1: Đã thêm 1 cho lần đặt cược đầu tiên, chỉ đơn giản là để giảm cơ hội hòa với người khác đặt cược 51.

Chỉnh sửa 2: Stole Sarcoma bot mở đầu vì nó có cơ hội tốt để không bị loại đầu tiên một cách nhất quán.

Chỉnh sửa 3: Bot sống sót rất tốt trong vòng đầu tiên, nhưng nó đang bị phá hủy dễ dàng ở giai đoạn sau. Thay đổi cách mà robot nghĩ về vòng thứ hai bây giờ khi một nửa người chết trong nước.

Chỉnh sửa 4: Bây giờ vòng thứ nhất đã tốt, tôi đã thay đổi cách xử lý vòng thứ hai. Chết rất nhiều ở vòng hai nên tôi cần sống sót bằng cách nào đó.

Bot máu

Làm một con bot khát nước tìm kiếm một cái chết. Ý tưởng là cố gắng giành chiến thắng trước các bot cá cược thấp và một khi nó đã vượt qua vòng tắm máu của vòng đầu tiên thì không thể ngăn cản được vì nó cần phải có lượng HP vượt trội để vượt qua kẻ thù.

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

Chỉ cần trả giá hơn một nửa hp của nó

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

mehan

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

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

Robbie Roulette

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

Bot này thực hiện một số phân tích đơn giản về lịch sử của bot đối phương hoặc trả giá bằng một nửa số điểm nhấn còn lại của nó

Trả giá càng cao thì càng ít cạnh tranh. Cảm ơn các bình luận đã đề xuất cải tiến.

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 và HalvsiesBot

Cám ơn vì đã trả lời câu hỏi của tôi. Kết quả cuối cùng là một bot phức tạp hơn.

HalvsiesBot là một bot 'cứ tiếp tục vượt qua một nửa' với cơ hội chiến thắng 50/50. Tôi đoán.

SurvivalistBot đưa ra một loạt các quyết định if-other cây khác dựa trên tập dữ liệu, bao gồm cả ghi đè lên cà vạt (nếu nó chạm 2 liên kết thì kamikazes sẽ tránh được cái chết của ba tie).

Con trăn của tôi hơi rỉ sét, vì vậy mã có thể hơi lỗi, vì vậy hãy sửa hoặc cập nhật nó.

Nó được xây dựng để cố gắng tìm ra các bit dữ liệu để suy ra những thứ như lượng HP còn lại, số lượng bot tối thiểu có khả năng chiến đấu, lượng HP tối thiểu để lại, đặt giá thầu trung bình. Nó cũng khai thác ngẫu nhiên trong các tình huống mơ hồ, chẳng hạn như các vở kịch mở hoặc các vấn đề đấu thầu tối ưu.

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

Hộp đựng

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

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

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

Bot tính toán

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 tính toán tích cực

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 chống đá

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

Nếu chúng ta có thể dự đoán hành động của đối thủ, chúng ta có thể đặt cược tối ưu! Nếu chúng tôi không thể (không đủ dữ liệu hoặc đối thủ quá ngẫu nhiên), thì ít nhất chúng tôi có thể làm những gì sẽ tối đa hóa tiềm năng chiến thắng của chúng tôi. Về mặt lý thuyết, ít nhất một nửa số bot còn sống sẽ chết mỗi vòng. Vì vậy, tôi có thể mong đợi có nhiều vòng log2 (còn sống). Lý tưởng nhất là chúng tôi sẽ chia hp của chúng tôi đồng đều giữa tất cả các vòng. Tuy nhiên, chúng tôi biết rằng một số bot sẽ ngu ngốc và tự tử / chết sớm, vì vậy chúng tôi nên đặt cược nhiều hơn một chút trong các vòng trước.

Tính toán tích cực của Bot tính toán sửa đổi mã Bot để cố gắng sống sót bằng cách tích cực hơn, với chi phí cho sức khỏe lâu dài. Chỉ mô phỏng sẽ cho biết nếu tiến độ hoặc giá trị chiến thắng.

Anti Kick Bot phải luôn luôn đánh bại nhà lãnh đạo hiện tại KickBot: P

EDIT: Đã thay thế Bot xác định bằng Anti Kick Bot, một bot thông minh hơn với các giá trị trả về gần như chính xác. Cũng ngăn chặn bỏ phiếu nhiều hơn đối thủ 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))

Đã quá muộn ... Tôi mệt mỏi ... không thể nghĩ ra một cái tên ... và định dạng của bot này thực sự giống với những cái khác, chỉ với một thuật toán hơi khác với lịch sử. Nó cố gắng để có được tỷ lệ hiện tại mà đối thủ đang có xu hướng đánh bạc ... hoặc một cái gì đó tương tự ... zzz

HalflifeS3

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

Coast Bot [Nghỉ hưu]

Sẽ cố gắng và vượt qua cuộc thi bằng cách chia đều số hp giữa các vòng. Sẽ đấu giá bất kỳ hp còn sót lại nào trong vòng đầu tiên để tạo cho mình cơ hội tốt hơn để lọt vào vòng "có thể có bờ biển".

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)

Bờ biển Bot V2

Vì tôi thích thử thách này rất nhiều, tôi chỉ phải làm một bot khác. Phiên bản này hy sinh một số hp sau đó bằng cách sử dụng nhiều hp hơn trong hai vòng đầu tiên.

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

Phần trăm Bot

Cố gắng tính toán phần trăm hp trung bình mà đối thủ bỏ ra và trả giá dựa trên đó.

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)

Nhất quán

Đặt cược cùng số tiền mỗi vòng. Nó không quá có khả năng sống sót trong các vòng đầu tiên, nhưng nếu nó đủ may mắn để đi đến cuối cùng, thì nó vẫn còn một lượng HP hợp lý.

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

Bot này chỉ đơn giản là cố gắng chống lại nhà lãnh đạo hiện tại có nghĩa là Kickbot bằng cách đánh bại nó trong vòng một và chơi tích cực hơn sau đó nếu nhận ra nó.

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)

Bot ba quý

Anh ấy sẽ không đánh bại MehBot hoặc SarcomaBot (s), nhưng tôi nghĩ anh ấy làm khá tốt. Khi tôi lần đầu tiên nhìn thấy thử thách, đây là điều đầu tiên xuất hiện trong đầu tôi, luôn * đặt cược 3/4 sức khỏe của bạn trừ khi không có lý do gì.

* sau khi bóng thấp vòng đầu tiên.

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

Bot thứ bảy

Sau thành công vừa phải của 3/4 bot, có một phần mới trong thị trấn, nó chỉ hợp lý.

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

Phân số hoàn hảo

Tôi là toàn bộ

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 muốn mọi người chơi tốt! Nếu đối thủ của nó tốt đẹp ở vòng trước, nó sẽ hy sinh bản thân để khuyến khích hành vi tốt đẹp ở người khác. Nếu đối thủ của nó có nghĩa là vòng trước, nó sẽ gây sát thương nhiều nhất có thể cho đối thủ, hy sinh nếu cần thiết. Nó trả giá một phần ba hp nếu nó không có lịch sử để làm việc. (Tôi hy vọng bot này sẽ có hiệu ứng gợn thú vị trên các chiến lược khác, không đến nỗi bot này sẽ có tỷ lệ thắng cao. Thật vui khi có một vài trong số này chơi)

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 sẽ tốt như bạn cần để tận dụng lợi thế của BandaidBot. Nó sẽ trở lại chỉ dưới một phần ba hp của mình trừ khi nó có thể giết chết đối thủ của mình với giá thấp hơn thế. Nếu đối thủ của nó trông giống BandaidBot, nó sẽ trả giá 2, biết rằng BandaidBot sẽ trả giá 1 vì GetAlongBot đã hòa hợp rất tốt với mọi người khác - một chiến thắng dễ dàng miễn là nó thực sự là BandaidBot ở đầu bên kia.

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)

Bot TENility

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 này cố gắng giữ giá trị yêu thích là 10, nhưng đôi khi nó thay đổi lựa chọn nếu cần phá vỡ một cà vạt (với giá trị yêu thích của nó tăng gấp đôi hoặc gấp bốn lần) hoặc để dành cho các vòng trong tương lai, nhưng không phải là số tiền tối ưu vì muốn nhầm lẫn đối thủ và nó không muốn xem xét đặt giá thầu ít hơn 2 bất cứ lúc nào vì tin chắc rằng sẽ tốt hơn nhiều so với hy vọng đối thủ sẽ trả giá dưới 1, nghĩa là 0.

PS: bot này có thể có vấn đề chiến lược nếu có nhiều hơn 2 ^ 9 bot.

Thận trọng

Lần đầu tiên gửi đến Câu đố lập trình bao giờ hết! Tìm thấy thử thách của bạn khá thú vị: P

Nếu vòng cuối cùng bit ít hơn hp, nếu không có lịch sử đặt cược một nửa hp cộng với một số tiền ngẫu nhiên nhỏ.

Nếu lịch sử kiểm tra hp của đối thủ và số vòng còn lại và cố gắng trả giá cao hơn hp / 2 của đối thủ bằng cách sử dụng bộ đệm bổ sung lên tới một phần của hp còn lại chia cho số vòng còn lại (bằng cách nào đó cố gắng bảo tồn hp còn lại bằng cách nào đó cho các vòng sau) . Kiểm tra xem bạn đang chi tiêu quá nhiều hp (đừng tự sát hoặc trả giá cao hơn đối thủ của bạn có thể).

Luôn luôn đúng cho các mối quan hệ như các bot khác làm.

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)

Thận trọngBot2

Quá nhiều tích cực vào vòng đầu tiên, bây giờ CautiousBot thậm chí còn thận trọng hơn ...

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)

Được rồi, tôi sẽ thử điều này.

SnetchBot

Kiểm tra các phân số sức khỏe mà đối thủ đã và đang đi cùng. Nếu đối thủ đã được nâng lên, đánh bại anh ta với nó.

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: thua rất nhiều ở vòng đầu tiên, điều chỉnh giới hạn ngẫu nhiên trong lượt đầu tiên

SquareUpBot

Có vẻ như không có nhiều bot chơi với sức mạnh thay vì phân số, vì vậy tôi quyết định tạo một cái, với một số tối ưu hóa tiêu chuẩn và xem nơi tôi sẽ đặt. Khá đơn giản.

Cũng cố gắng xác định xem bot đối phương không cố sử dụng một số phần không đổi, bởi vì sức mạnh > phân số .

EDIT: Tôi là một hình nộm và máy dò phân số của tôi không thể hoạt động. Sửa chữa ngay.

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