Robot Roulette: Đánh bạc cao


56

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 .


4
FWIW, tôi dự định sử dụng một mạng lưới thần kinh được đào tạo trên tất cả các bot khác chỉ để giải trí một khi bạn thiết lập bộ điều khiển :)
Quintec

2
Việc kiểm tra loại là vì lợi ích của antiantiantiantiupyoursbot. Tôi sẽ tìm một cách khác
KBriggs

3
@Sarcoma Có vẻ như cuộc thi này đã gây ra một cuộc chiến mã nghiêm trọng. Cuộc thi này chưa kết thúc, nhưng tôi đã mong chờ sự phát triển của điều này. Thậm chí có thể là bước tiếp theo, AI tăng cường cạnh tranh: P
Markov Chained

3
WOOOOOOOOOOOOOO!
Sarcoma

5
Ôi chúa ơi. Việc cố tình trolling thay đổi mean_kick để luôn trả về số 0 khi nó được sử dụng rất nhiều nơi là tuyệt vời.
Magua

Câu trả lời:


12

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


Bình luận không dành cho thảo luận mở rộng; cuộc trò chuyện này đã được chuyển sang trò chuyện .
Mego

17

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.


1
Hahahaha cái này đẹp quá Tôi không quyết định liệu tôi có nên cho phép hay không, nhưng tôi sẽ cho nó chơi ngay bây giờ vì tôi không nghĩ rằng nó không được phép. Bạn đã sai tên hàm ở một vài nơi - xem trình điều khiển trên github.
KBriggs

1
Nó làm rất tốt, rõ ràng, nhưng nó vẫn thua Kick Bot
KBriggs

1
Ha, nỗ lực tốt!
Sarcoma

1
@Sarcoma Tôi không thể làm điều đó mà không có bạn. ;) Tôi thực sự thích bot của bạn, bạn thân.
Qfwfq

1
Bảo vệ Upyoursbot của Sarcomabot thực sự gây rối với cái này
KBriggs

15

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

11
Welp, đó là điều không thể tránh khỏi
KBriggs

Tôi cũng sẽ thêm một bot hòa bình nhưng tôi không muốn tràn ngập thử thách của bạn với các bot chết não
DobromirM

5
Dựa trên một số thử nghiệm nhanh, bot kamikaze không thay đổi nhiều - tất cả những gì nó làm là loại bỏ một bot khác khỏi vòng một cách ngẫu nhiên, qua một số lượng giải đấu đủ lớn, chỉ đơn giản là trung bình bằng không. The One nóng là gọn gàng, mặc dù. Không có nó, AverageBot của tôi có xu hướng hoạt động tốt nhất - nhưng nếu có một vài OneShots đang hoạt động, sẽ làm lệch trung bình về số lượng lớn và có xu hướng làm cho AverageBots chết nhanh chóng. Tương tự cho LastBot. Bạn thực sự có thể gây rối với hành vi của các robot khác bằng cách làm lệch các mẫu cá cược của riêng bạn. Với OneShot đang chơi, RandomBot thắng. Không có nó, AverageBot thắng.
KBriggs

14

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.


Rất đẹp, cảm ơn vì bot! Tôi sẽ cung cấp một số số liệu thống kê khi tôi nhận được một vài chi tiết.
KBriggs

Tôi là người mới làm quen với python nên tôi không chắc cú pháp có đúng không, vui lòng cho tôi biết nếu điều đó xảy ra
Yodie

Nó chạy, vì vậy không phải lo lắng ở đó
KBriggs

@Yodie Là một đánh giá mã nhỏ: Cơ thể chức năng của bạn nên được thụt lề theo một mức độ (sự cần thiết cú pháp); opp_hp +1thiếu một không gian để được pythonic; ý kiến ​​của bạn bắt đầu với số lượng khoảng trắng không cân bằng. Cuối cùng, chức năng của bạn là thiếu một chuỗi.
Jonathan Frech

2
Tôi nghĩ rằng bot này làm khá tốt nếu nó vượt qua vòng đầu tiên, nhưng vì rất nhiều người đặt cược lớn nên anh ta không làm tròn đầu tiên nên nó hầu như luôn chết sớm. Bạn có thể cải thiện hiệu suất bằng cách thay đổi hành vi ban đầu để trả giá cao hơn khi không có lịch sử. Ví dụ: nếu bạn tăng gấp ba lần đặt cược không có lịch sử của mình, bot này sẽ giành chiến thắng với tỷ lệ thuận lợi giữa các thí sinh cho đến nay.
KBriggs

11

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

Đẹp. Tôi đang thấy rất nhiều bài nộp trực tiếp phản đối người khác, đó chính xác là những gì tôi đã hy vọng
KBriggs

Quay trở lại trên dòng cuối cùng?
Veskah

Ah tôi chưa chạy nó hoặc tôi sẽ bắt được nó.
KBriggs

Điều này đã có một dẫn thoải mái!
KBriggs

1
@KBriggs ở đây là một số sao lưu!
Johan

8

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ỏ.

Bot đẳng cấp

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.


Bình luận không dành cho thảo luận mở rộng; cuộc trò chuyện này đã được chuyển sang trò chuyện .
Mego

8

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

Bạn sẽ phải đổi tên anh ta, đã có bot kamikaze ^ _ ^
KBriggs

Tuy nhiên, cho đến nay, người này là người chiến thắng
KBriggs

Chức năng của bạn ceildường như không được xác định.
Jonathan Frech

Tôi đã đổi thành np.ceil () để chạy nó
KBriggs

đã được chỉnh sửa, cảm ơn vì đã đề phòng
Belhenix

7

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

Rất tuyệt. Có bao nhiêu là cần thiết? Có lẽ tôi sẽ phải giới hạn số lượng mục nhập ...
KBriggs

Khối mã của bạn dường như bỏ lỡ dòng đầu tiên của nguồn.
Jonathan Frech

Tôi không chắc có bao nhiêu sẽ cần trong một mô phỏng, nhưng nếu bất kỳ bot nào từng thấy nhau, chúng sẽ tăng cơ hội chiến thắng một trong số chúng. Tôi đoán rằng có 10% nhóm là bot nhóm nên đủ để tạo ra sự khác biệt đáng kể. Ngoài ra, khối mã thiếu điều đầu tiên -> đây là bài viết đầu tiên của tôi ở đây Tôi không biết tại sao định dạng lại làm điều đó nhưng vâng, đó chỉ là khai báo phương thức.
Jim Hat

Bạn có một lỗi: bot sẽ xác định bất kỳ ai có len (lịch sử)> 1 là thành viên băng đảng
KBriggs

Xấu của tôi, nên được sửa chữa ngay bây giờ.
Jim Hat

6

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.


Điều này thất bại với chia cho 0 nếu alive==8. Tôi có thể tự thay đổi nó thành tổng số bot, nhưng nó mở rộng các quy tắc vì đó không phải là đầu vào cho chức năng của bạn - tất cả những gì bạn biết nếu bạn còn lại bao nhiêu đối thủ tại bất kỳ thời điểm nào, không phải là bao nhiêu bạn bắt đầu chống lại.
KBriggs

Tôi đã cập nhật cuộc thi dựa trên yêu cầu của bạn
KBriggs

@KBriggs Cảm ơn :)
Quintec

Bạn cũng cần thêm 1 để bắt đầu sống, vì đây là 0 cho vòng đầu tiên
KBriggs

@KBriggs đã sửa, thực sự nên +2 để nó không trả về 0, lol
Quintec

6

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ể.


Có một điều kiện where np.random.randint(hp/5, hp/2)có thể thất bại nếu hp/5 == hp/2, tức là nếu hp==0hoặchp==1
KBriggs

3
Nếu HP bằng 0, thì tôi không nên được gọi. : P Bạn nói đúng về HP 1.
Draco18

6

Bot Spitball

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

    if value < 10:
        value = 10

    if value >= hp:
        value = hp-1

    return value

Đư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

1
Giá thầu của bạn phải là một số nguyên, miễn là bạn đặt sàn hoặc trần giá trị cơ sở của bạn để loại bỏ số thập phân thì không sao
KBriggs

Đúng, tôi sàn nó ngay sau khi thực hiện tất cả các tính toán. Cảm ơn đã trả lời nhanh chóng!
MegaWidget

2
Bạn có thể tối ưu hóa điều này nếu bạn không chia hp của mình cho số lượng thí sinh còn lại nhưng theo số vòng còn lại (nên là math.ceil (math.log (còn sống, 2))
Black Owl Kai

1
Dựa trên các bot khác, hầu hết trong số chúng dường như trả giá trước, vì vậy điều này có thể cải thiện nếu bạn tăng giá thầu vòng đầu tiên trên 10
KBriggs

Đó là cả hai ý tưởng tốt! Tôi đã không nhận ra rằng số lượng bot không giống với số vòng còn lại (lúc đầu tôi đã hiểu sai quy tắc của cuộc thi). Tôi sẽ thử thực hiện chúng vào ngày mai. Cảm ơn!
MegaWidget

5

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)

Vị trí thứ 5 trong lần thử đầu tiên, không tệ chút nào
KBriggs

5

Bot 13

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

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.


Bạn đã dẫn đầu, rất tốt đẹp! Hãy cẩn thận, bạn có thể muốn thêm bảo vệ ký sinh trùng, vì các bot dẫn đầu trở thành mục tiêu cho những thứ như UpYoursBot. Kiểm tra SarcomaBots để biết ý tưởng bảo vệ nếu bạn cần chúng.
KBriggs

5

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

2
Tôi nghĩ len (lịch sử) * len (lịch sử) có thể được đổi thành len (lịch sử) ** 2 nếu kiến ​​thức về trăn của tôi là chính xác.
Yodie

Bạn có số chia cho 0 khi len (lịch sử) == 0
KBriggs

Mã đã được cập nhật. Khi không tìm thấy lịch sử, nó sẽ chuyển sang phần đầu tiên
Markov Chained

xin chào .............
Sarcoma

2
@Sarcoma đó là một thế giới bot khốn kiếp!
Markov bị xích

5

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

Có khá nhiều bot tồn tại để tận dụng chính xác hành vi này, vì vậy bạn có thể gặp khó khăn trong việc đạt được lực kéo!
KBriggs

@KBriggs Thực hiện một số cập nhật, tôi không mong đợi phiên bản đầu tiên sẽ làm tốt như vậy, hy vọng, bản cập nhật này sẽ mang đến cơ hội chiến đấu nhiều hơn
meh Man

Ồ, điều đó đã tạo ra một sự khác biệt lớn, tôi nghĩ bạn là người đầu tiên. Cập nhật sẽ được đăng trong một vài phút. Bạn có thể cần cung cấp cho bot của mình một hệ thống miễn dịch (Xem SarcomaBot) nếu bạn muốn thực hiện tốt điều này.
KBriggs

@KBriggs Tôi không mong đợi sẽ làm tốt điều này, tôi nghĩ tốt nhất nó sẽ đứng đầu 10. Dù sao tôi cũng đã thêm một người khác chỉ để thấy hiệu ứng hp vòng đầu tiên. Bạn có thể chạy cả hai để tôi có thể thấy kết quả của cả hai? Cảm ơn bạn
meh Man

@KBriggs Xin vui lòng làm điều này là tốt, gracias Manyas
meh Man

4

Robbie Roulette

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

Bot 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ó


4

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)

1
Ý tưởng gọn gàng, nhưng tôi thấy hai vấn đề. Một là hầu hết các bot khác đấu giá lớn ở vòng đầu tiên, vì vậy, cái này có thể sẽ chết sớm trong hầu hết thời gian. Thứ hai là trong trận chung kết, hầu hết các bot đều trả giá hp-1, vì vậy, cái này sẽ mất những cái đó trừ khi bạn có gấp đôi hp của chúng. Nhưng đối với các vòng trung gian tôi thích ý tưởng. Nếu bạn giải quyết hai trường hợp đặc biệt, bạn có thể cải thiện hiệu suất.
KBriggs

4

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

Opponent_Average_Bid = Opponent_Remaining_HP / float(len(history)) ZeroDivisionError: float division by zero. Dòng này cần xử lý trường hợp lịch sử 0 độ dài.
KBriggs

Cảm ơn, tôi sẽ sửa nó.
SSight3

Đã sửa. Hãy cho tôi biết nếu có bất kỳ lỗi nào khác.
SSight3

1
Vài lỗi cú pháp: thiếu: `sau else, math.[func] -> np.[func]và tại một thời điểm bạn sử dụng Lowestmà bạn có ý nghĩa LowestBid. Tất cả được cố định trong bộ điều khiển trên github và điểm số được cập nhật sớm.
KBriggs

Cảm ơn. Đã sửa tất cả các lỗi đã nói ở trên.
SSight3

4

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


Dễ thương. Tôi nghĩ rằng điều này sẽ làm tốt hơn với một nhóm bot rất lớn.
KBriggs

Đôi khi tôi gặp lỗi với cái này : return np.max(theoreticalBet, hp - 1): AxisError: axis 23 is out of bounds for array of dimension 0. Tôi đã đăng một liên kết đến bộ điều khiển để bạn có thể kiểm tra nó.
KBriggs

@KBriggs Cập nhật mã để sửa nó.
Bob Cratchit

1
xác nhận, cập nhật điểm đến. Bạn chắc chắn nằm trong top 10.
KBriggs

@KBriggs Tôi đã thêm một vài bot để dùng thử :)
Bob Cratchit

4

GenericBot

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

Đã 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


bạn cần sử dụng np.maximumthay vì np.max, tương tự chomin
KBriggs

@KBriggs Cảm ơn :) Hmm, có vẻ như các bot chung điều khiển trò chơi này
Quintec

Có vẻ như chúng sẽ là những mục tiêu khá dễ dàng, tôi ngạc nhiên là chưa có ai tạo ra ký sinh trùng
KBriggs

@KBriggs Vâng, tôi rất ngạc nhiên. Thời gian để thêm bảo vệ ...
Quintec

Vẫn có kế hoạch làm cho neuralbot?
KBriggs

4

HalflifeS3

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

4

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)

Ý tưởng khá tuyệt. Sack vòng đầu tiên là một xu hướng mới trong bot, và nó dường như đang hoạt động khá tốt.
KBriggs

@KBriggs Tôi đã cập nhật phản hồi này để chứa nỗ lực thứ hai của mình. Đề cập đến bạn theo các quy tắc mới. Câu đố tuyệt vời btw!
Wazz

Muốn tôi nhập cả hai, hoặc chỉ phiên bản mới nhất? Ngay bây giờ, nó chỉ là V2
KBriggs

@KBriggs Tôi muốn cả hai cùng tham gia nếu không sao. Sẽ rất tốt để xem làm thế nào họ cân nhắc với nhau.
Wazz

Hiệu suất khá giống nhau về tổng thể
KBriggs

4

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

Xin lỗi, bây giờ đã quá muộn để sửa nó, nhưng bot của tôi đã sử dụng đủ HP để kết thúc chiến đấu với từng đối thủ một lần, chứ không phải vào vòng cuối cùng. Đó là điều xấu của tôi: P
Kevin - Tái lập Monica

4

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)

1
Tôi nghĩ rằng vết lõm của bạn là một chút.
Jonathan Frech

Rất tiếc, cảm ơn, trình soạn thảo mã lạ đã
gặp rắc

một bài học quý giá về việc tin tưởng mã mà bạn không kiểm soát
OganM

4

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

Dựa trên xác suất loại trừ này, có lẽ bạn cũng có thể thoát khỏi các giá thầu nhỏ hơn trong vòng 2. Điều này làm tốt, nhưng một số điều chỉnh nhỏ có thể làm cho nó làm tốt hơn rất nhiều.
KBriggs

@KBriggs Đã thêm một bot mới với tỷ lệ cược mới và được cải thiện;)
Joshua Webb

Muốn cả hai trong đó, hoặc chỉ 1?
KBriggs

@KBriggs Tôi không biết nếu tôi bỏ lỡ thời hạn, nhưng tôi đã thêm một bot cuối cùng, nếu tôi thực hiện kịp thời, bạn có thể xóa hai bot phân đoạn khác
Joshua Webb

1
Đúng, bạn vẫn còn thời gian
KBriggs

4

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)

Ý tưởng thực sự gọn gàng. Tôi tự hỏi nó sẽ có tác động đến mức nào
KBriggs

lỗi: return np.random.randint(history[-1], hp/2): ValueError: low >= highTrường hợp này cần được xử lý bằng cách nào đó
KBriggs

@KBriggs nên được sửa ngay bây giờ!
Maya Sol

@KBriggs được cập nhật để sửa lỗi ngẫu nhiên
Maya Sol

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.


Tôi nghi ngờ bạn không phải lo lắng về việc có 2 ^ 9 đối thủ ^ _ ^.
KBriggs

Nhưng với đặt cược mở 10, anh ấy sẽ hiếm khi vượt qua vòng đầu tiên
KBriggs

Bot này nghĩ rằng, nếu một số bot thực sự muốn cung cấp hơn 10 hp trong vòng đầu tiên, nó không đáng để chiến đấu.
AlexRacer

Haha đủ công bằng
KBriggs

3

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)

Bạn có một lỗi trong đó nó vẫn đang gọi randint khi bộ đệm = 0 : buffer_bet = np.random.randint(0, buffer) if buffer > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high. Lưu ý rằng bộ đệm là một từ khóa trong python, bạn có thể muốn chọn một tên biến khác.
KBriggs

Ồ có vẻ như đó là bộ đệm becasuse không phải lúc nào cũng là một số nguyên - bạn có thể đang chia cho số 0 tại một số điểm. Vui lòng kiểm tra logic cẩn thận. Tôi đã làm cho nó chạy, nhưng bạn có thể có thể sửa các trường hợp góc.
KBriggs

Bắt tốt đẹp @KBriggs. Nghĩ rằng tôi đã sửa nó.
Jesús Ros

Tôi vẫn nhận được một lỗi : buff_bet = np.random.randint(0, buff) if buff > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high. Có vẻ như buff đôi khi là một số dấu phẩy động giữa 0 và 1, có lẽ được chuyển thành 0 bên trong randint. Đây hoạt động nếu bạn cast buffđến inttrước khi cuộc gọi
KBriggs

@KBriggs có lẽ vì ceiltrả về a float. Bỏ lỡ một ... Ty lần nữa: P
Jesús Ros

3

Đượ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


Cú đánh đầu khá tốt, cập nhật điểm số đến
KBriggs

@KBriggs Chỉnh sửa một chút (chỉ giới hạn vòng ngẫu nhiên đầu tiên). Mặc dù tôi đã rất ngạc nhiên khi cao đến vị trí thứ 10. Nếu điều này làm tồi tệ hơn, tôi sẽ quay trở lại cái đầu tiên: D
snetch

Bạn vắt thêm một ít nước trái cây từ anh ấy
KBriggs

3

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

Một phát súng đầu tiên không tệ, điểm số đã được cập nhật
KBriggs

@KBriggs Tôi đã cập nhật bot để trình phát hiện phân số thực sự hoạt động.
Bụi kim cương
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.