Kết quả cuối cùng

Cuộc thi kết thúc. Xin chúc mừng hard_coded!

Một số sự thật thú vị:

• Trong 31600 trên tổng số 40920 phiên đấu giá (77,2%), người chiến thắng trong vòng đầu tiên đã giành được nhiều vòng nhất trong phiên đấu giá đó.

• Nếu các bot mẫu được đưa vào thi đấu, chín vị trí hàng đầu sẽ không thay đổi ngoại trừ điều đó AverageMinevà heuristsẽ hoán đổi vị trí của họ.

• Top 10 kết quả trong một cuộc đấu giá:

[2, 2, 3, 3] 16637
[0, 3, 3, 4] 7186
[1, 3, 3, 3] 6217
[1, 2, 3, 4] 4561
[0, 1, 4, 5] 1148
[0, 2, 4, 4] 1111
[2, 2, 2, 4] 765
[0, 2, 3, 5] 593
[1, 1, 4, 4] 471
[0, 0, 5, 5] 462

• Số lượng tie (số phiên đấu giá mà vòng thứ i không có người chiến thắng) : [719, 126, 25, 36, 15, 58, 10, 7, 19, 38].

• Giá thầu trung bình của vòng thứ i : [449.4, 855.6, 1100.8, 1166.8, 1290.6, 1386.3, 1500.2, 1526.5, 1639.3, 3227.1].

Bảng điểm

Bot count: 33
hard_coded            Score: 16141  Total: 20075170
eenie_meanie_more     Score: 15633  Total: 18513346
minus_one             Score: 15288  Total: 19862540
AverageMine           Score: 15287  Total: 19389331
heurist               Score: 15270  Total: 19442892
blacklist_mod         Score: 15199  Total: 19572326
Swapper               Score: 15155  Total: 19730832
Almost_All_In         Score: 15001  Total: 19731428
HighHorse             Score: 14976  Total: 19740760
bid_higher            Score: 14950  Total: 18545549
Graylist              Score: 14936  Total: 17823051
above_average         Score: 14936  Total: 19712477
below_average         Score: 14813  Total: 19819816
Wingman_1             Score: 14456  Total: 18480040
wingman_2             Score: 14047  Total: 18482699
simple_bot            Score: 13855  Total: 20935527
I_Dont_Even           Score: 13505  Total: 20062500
AntiMaxer             Score: 13260  Total: 16528523
Showoff               Score: 13208  Total: 20941233
average_joe           Score: 13066  Total: 18712157
BeatTheWinner         Score: 12991  Total: 15859037
escalating            Score: 12914  Total: 18832696
one_upper             Score: 12618  Total: 18613875
half_in               Score: 12605  Total: 19592760
distributer           Score: 12581  Total: 18680641
copycat_or_sad        Score: 11573  Total: 19026290
slow_starter          Score: 11132  Total: 20458100
meanie                Score: 10559  Total: 12185779
FiveFiveFive          Score: 7110   Total: 24144915
patient_bot           Score: 7088   Total: 22967773
forgetful_bot         Score: 2943   Total: 1471500
bob_hater             Score: 650    Total: 1300
one_dollar_bob        Score: 401    Total: 401

Trong trò chơi này, chúng tôi sẽ mô phỏng một phiên đấu giá thầu kín.

Mỗi phiên đấu giá là một trò chơi 4 người, bao gồm 10 vòng. Ban đầu, người chơi không có tiền. Khi bắt đầu mỗi vòng, mỗi người chơi sẽ nhận được 500 đô la, và sau đó đưa ra giá thầu của riêng họ. Giá thầu có thể là bất kỳ số nguyên không âm nào nhỏ hơn hoặc bằng số tiền họ có. Thông thường, một người trả giá cao nhất sẽ giành chiến thắng trong vòng này. Tuy nhiên, để làm cho mọi thứ thú vị hơn, nếu một số người chơi trả giá như nhau, giá thầu của họ sẽ không được tính đến (do đó không thể giành chiến thắng trong vòng này). Ví dụ: nếu bốn người chơi trả giá 400 400 300 200, thì một người trả giá 300 thắng; nếu họ trả giá 400 400 300 300, không ai thắng. Người chiến thắng nên trả những gì họ trả giá.

Vì đây là phiên đấu giá "niêm phong giá thầu", người chơi thông tin duy nhất sẽ biết về đấu thầu là người chiến thắng và họ đã trả bao nhiêu khi vòng tiếp theo bắt đầu (để người chơi có thể biết mọi người có bao nhiêu).

Chấm điểm

Một phiên đấu giá sẽ được tổ chức cho mọi kết hợp 4 người chơi có thể. Nghĩa là, nếu có tổng cộng N bot, sẽ có đấu giá _N C ₄ . Bot chiến thắng nhiều vòng nhất sẽ là người chiến thắng cuối cùng. Trong trường hợp có hòa, bot nào trả ít nhất trong tổng số sẽ thắng. Nếu vẫn còn một ràng buộc, giống như cách đấu thầu, các mối quan hệ đó sẽ bị xóa.

Mã hóa

Bạn nên triển khai lớp Python 3 với hàm thành viên play_round(và các lớp __init__khác nếu bạn cần). play_roundnên lấy 3 đối số (bao gồm cả bản thân). Đối số thứ hai và thứ ba sẽ theo thứ tự: id của người chiến thắng của vòng trước, theo sau là số tiền họ đã trả. Nếu không ai thắng hoặc đó là vòng đầu tiên, cả hai sẽ là -1. Id của bạn sẽ luôn là 0 và id 1 Ném3 sẽ là những người chơi khác theo thứ tự chỉ được xác định bởi vị trí trên bài đăng này.

Quy tắc bổ sung

1. Xác định: Hành vi của chức năng của bạn chỉ nên phụ thuộc vào các đối số đầu vào trong phiên đấu giá. Đó là, bạn không thể truy cập các tệp, thời gian, biến toàn cục hoặc bất cứ thứ gì sẽ lưu trữ trạng thái giữa các phiên đấu giá hoặc bot khác nhau . Nếu bạn muốn sử dụng trình tạo giả ngẫu nhiên, tốt hơn là bạn nên tự viết nó (để tránh ảnh hưởng đến các chương trình của người khác như randomtrong Python lib) và đảm bảo rằng bạn đã đặt lại nó với một hạt giống cố định trong __init__hoặc vòng đầu tiên.

2. Ba Bots mỗi người: Bạn được phép gửi tối đa 3 bot, vì vậy bạn có thể phát triển một chiến lược để làm cho bot của bạn "hợp tác" theo một cách nào đó.

3. Không quá chậm: Vì sẽ có nhiều phiên đấu giá, hãy đảm bảo rằng các bot của bạn sẽ không chạy quá chậm. Các bot của bạn sẽ có thể hoàn thành ít nhất 1.000 phiên đấu giá trong một giây.

Bộ điều khiển

Đây là bộ điều khiển tôi đang sử dụng. Tất cả các bot sẽ được nhập khẩu và thêm bot_listvào theo thứ tự trên bài đăng này.

# from some_bots import some_bots

bot_list = [
    #one_bot, another_bot, 
]

import hashlib

def decide_order(ls):
    hash = int(hashlib.sha1(str(ls).encode()).hexdigest(), 16) % 24
    nls = []
    for i in range(4, 0, -1):
        nls.append(ls[hash % i])
        del ls[hash % i]
        hash //= i
    return nls

N = len(bot_list)
score = [0] * N
total = [0] * N

def auction(ls):
    global score, total
    pl = decide_order(sorted(ls))
    bots = [bot_list[i]() for i in pl]
    dollar = [0] * 4
    prev_win, prev_bid = -1, -1
    for rounds in range(10):
        bids = []
        for i in range(4): dollar[i] += 500
        for i in range(4):
            tmp_win = prev_win
            if prev_win == i: tmp_win = 0
            elif prev_win != -1 and prev_win < i: tmp_win += 1
            bid = int(bots[i].play_round(tmp_win, prev_bid))
            if bid < 0 or bid > dollar[i]: raise ValueError(pl[i])
            bids.append((bid, i))
        bids.sort(reverse = True)
        winner = 0
        if bids[0][0] == bids[1][0]:
            if bids[2][0] == bids[3][0]: winner = -1
            elif bids[1][0] == bids[2][0]: winner = 3
            else: winner = 2
        if winner == -1:
            prev_win, prev_bid = -1, -1
        else:
            prev_bid, prev_win = bids[winner]
            score[pl[prev_win]] += 1
            total[pl[prev_win]] += prev_bid
            dollar[prev_win] -= prev_bid

for a in range(N - 3):
    for b in range(a + 1, N - 2):
        for c in range(b + 1, N - 1):
            for d in range(c + 1, N): auction([a, b, c, d])

res = sorted(map(list, zip(score, total, bot_list)), key = lambda k: (-k[0], k[1]))

class TIE_REMOVED: pass

for i in range(N - 1):
    if (res[i][0], res[i][1]) == (res[i + 1][0], res[i + 1][1]):
        res[i][2] = res[i + 1][2] = TIE_REMOVED
for sc, t, tp in res:
    print('%-20s Score: %-6d Total: %d' % (tp.__name__, sc, t))

Ví dụ

Nếu bạn cần một trình tạo giả ngẫu nhiên, đây là một cách đơn giản.

class myrand:
    def __init__(self, seed): self.val = seed
    def randint(self, a, b):
        self.val = (self.val * 6364136223846793005 + 1) % (1 << 64)
        return (self.val >> 32) % (b - a + 1) + a

class zero_bot:
    def play_round(self, i_dont, care): return 0

class all_in_bot:
    def __init__(self): self.dollar = 0
    def play_round(self, winner, win_amount):
        self.dollar += 500
        if winner == 0: self.dollar -= win_amount
        return self.dollar

class random_bot:
    def __init__(self):
        self.dollar = 0
        self.random = myrand(1)
    def play_round(self, winner, win_amount):
        self.dollar += 500
        if winner == 0: self.dollar -= win_amount
        return self.random.randint(0, self.dollar)

class average_bot:
    def __init__(self):
        self.dollar = 0
        self.round = 11
    def play_round(self, winner, win_amount):
        self.dollar += 500
        self.round -= 1
        if winner == 0: self.dollar -= win_amount
        return self.dollar / self.round

class fortytwo_bot:
    def play_round(self, i_dont, care): return 42

Kết quả

all_in_bot           Score: 20     Total: 15500
random_bot           Score: 15     Total: 14264
average_bot          Score: 15     Total: 20000
TIE_REMOVED          Score: 0      Total: 0
TIE_REMOVED          Score: 0      Total: 0

Người chiến thắng là all_in_bot. Lưu ý rằng zero_botvà fortytwo_botcó cùng số điểm và tổng số, vì vậy chúng bị xóa.

Những bot này sẽ không được đưa vào cuộc thi. Bạn có thể sử dụng chúng nếu bạn nghĩ rằng chúng là tuyệt vời.

Cuộc thi cuối cùng sẽ được tổ chức vào 2017/11/23 14:00 (UTC) . Bạn có thể thực hiện bất kỳ thay đổi cho bot của bạn trước đó.

hard_coding

class hard_coded:
  def __init__(self):
    self.money = 0
    self.round = 0

  def play_round(self, did_i_win, amount):
    self.money += 500
    self.round += 1
    if did_i_win == 0:
      self.money -= amount
    prob = [500, 992, 1170, 1181, 1499, 1276, 1290, 1401, 2166, 5000][self.round - 1]
    if prob > self.money:
      return self.money
    else:
      return prob    

Bot này là kết quả của việc đào tạo di truyền chống lại rất nhiều bot giả ngẫu nhiên khác (và một số bot trong các câu trả lời khác). Cuối cùng tôi đã dành một chút thời gian để tinh chỉnh, nhưng cấu trúc của nó thực sự rất đơn giản.

Các quyết định chỉ dựa trên một bộ thông số cố định chứ không dựa trên kết quả của các vòng trước.

Chìa khóa dường như là vòng đầu tiên: bạn phải đi tất cả, đấu thầu 500 là di chuyển an toàn. Quá nhiều bot đang cố gắng vượt qua bước đi ban đầu bằng cách đặt giá thầu 499 hoặc 498. Chiến thắng vòng đầu tiên mang lại cho bạn một lợi thế lớn cho phần còn lại của phiên đấu giá. Bạn chỉ có 500 đô la phía sau, và bạn có thời gian để phục hồi.

Đặt cược an toàn trong vòng thứ hai là hơn 990, nhưng ngay cả đặt giá thầu 0 cũng cho kết quả tốt. Trả giá quá cao và chiến thắng có thể tồi tệ hơn thua vòng này.

Trong vòng thứ ba, hầu hết các bot ngừng leo thang: 50% trong số chúng có ít hơn 1500 đô la, vì vậy không cần phải lãng phí tiền cho vòng này, 1170 là một sự đánh đổi tốt. Điều tương tự trong vòng thứ tư. Nếu bạn thua ba người đầu tiên, bạn có thể giành được thứ này rất rẻ, và vẫn có đủ tiền cho lần tiếp theo.

Sau đó, số tiền trung bình cần thiết để giành chiến thắng trong một vòng là 1500 đô la (đó là kết luận hợp lý: mọi người đều thắng một vòng bốn giờ, trả giá ít hơn để giành chiến thắng sau đó chỉ là lãng phí tiền, tình hình đã ổn định và nó chỉ là vòng cướp từ bây giờ).

Vòng cuối cùng phải là tất cả và các tham số khác được tinh chỉnh để giành chiến thắng trong vòng cuối cùng bằng cách đặt giá thầu càng thấp càng tốt cho đến lúc đó.

Rất nhiều bot cố gắng giành chiến thắng trong vòng thứ chín bằng cách đấu giá hơn 2000 đô la, vì vậy tôi đã tính đến điều đó và cố gắng vượt qua chúng (dù sao tôi cũng không thể thắng cả hai vòng cuối cùng, và cuối cùng sẽ khó hơn).

Trên mức trung bình

Giá thầu trên số tiền trung bình mà người chơi khác có. Chào giá tất cả mọi thứ trong vòng cuối cùng.

class above_average:
  def __init__(self):
    self.round = 0
    self.player_money = [0] * 4
  def play_round(self, winner, winning_bid):
    self.round += 1
    self.player_money = [x+500 for x in self.player_money]
    if winner != -1:
      self.player_money[winner] -= winning_bid
    if self.round == 10:
      return self.player_money[0]
    bid = sum(self.player_money[1:]) / 3 + 1
    if bid > self.player_money[0]:
      return self.player_money[0]
    return min(self.player_money[0], bid)

Tôi thậm chí không

class I_Dont_Even:
	def __init__(self):
		self.money = 0
		self.round = 0
	def play_round(self, loser, bid):
		self.money += 500 - (not loser) * bid
		self.round += 1
		return self.money * (self.round & 1 or self.round == 10)

Chỉ tham gia vào các vòng lẻ và vòng cuối cùng.

Bot quên lãng không biết anh ta có bao nhiêu tiền, vì vậy anh ta chỉ đưa vào số tiền anh ta được trao cho vòng này. Nếu cuối cùng anh ta thấy mình có một số tiền, anh ta chỉ quyên góp cho một tổ chức từ thiện.

class forgetful_bot:
  def play_round(self, winner, amt):
    return 500

Một Thượng

Tôi không biết nhiều về Python, vì vậy tôi có thể mắc một số lỗi

class one_upper:
    def __init__(self): 
        self.money = 0
        self.round = 0
    def play_round(self, winner, win_amount):
        self.money += 500
        if winner == 0: self.money -= win_amount
        self.round += 1
        bid = win_amount + 1
        if self.money < bid or self.round == 10:
            bid = self.money
        return bid

giá thầu cao hơn 1 so với giá thầu chiến thắng trước đó hoặc tham gia tất cả trong vòng cuối cùng.

Trong tương lai tôi có thể quyết định một chiến lược khác khi nào win_amountlà -1

Bot bệnh nhân

class patient_bot:
    def __init__(self):
        self.round = 0
        self.money = 0
    def rand(self, seed, max):
        return (394587485 - self.money*self.round*seed) % (max + 1)
    def play_round(self, winner, amount):
        self.round += 1
        self.money += 500
        if winner == 0:
            self.money -= amount
        if self.round < 6:
            return 0
        else:
            bid = 980 + self.rand(amount, 35)
            if self.money < bid or self.round == 10:
                bid = self.money
            return bid

Đấu giá không có gì trong năm vòng đầu tiên, sau đó trả giá ~ 1000 đô la cho bốn vòng tiếp theo, và cuối cùng trả giá mọi thứ nó có trong vòng cuối cùng.

Sao chép hay buồn

Bot thứ ba và cuối cùng.
Bot này sẽ trả giá chính xác cùng số tiền với người chiến thắng trước đó (bao gồm cả chính nó). Tuy nhiên, nếu nó không có đủ tiền mặt để làm điều đó thì thật đáng buồn, và sẽ trả một hóa đơn 1 đô la với nước mắt thay vào đó. Trong vòng cuối cùng, nó sẽ đi tất cả.

class copycat_or_sad:
  def __init__(self):
    self.money = 0
    self.round = -1
  def play_round(self, winner, win_amount):
    # Default actions:
    #  Collect 500 dollars
    self.money += 500
    #  If it was the winner: subtract the win_amount from his money
    if winner == 0:
      self.money -= win_amount
    #  One round further
    self.round += 1

    # If it's the final round: bid all-in
    if self.round == 9:
      return self.money
    # Else-if there was no previous winner, or it doesn't have enough money left: bid 1
    if win_amount < 1 or self.money < win_amount:
      return 1
    # Else: bid the exact same as the previous winner
    return win_amount

Tôi không bao giờ lập trình bằng Python, vì vậy nếu bạn thấy bất kỳ lỗi nào hãy cho tôi biết ..

Chạy thử nghiệm

Tôi đã chỉnh sửa một lần chạy thử trước đó được kết hợp bởi Steadybox trong lần gửi mới nhất.

Tôi đang đăng nó ở đây để có một nơi mà liên kết có thể được cập nhật với các phiên bản gần đây hơn, bài đăng này là một wiki cộng đồng vì vậy hãy cập nhật nó nếu bạn đăng một bài mới, sửa một bài cũ hoặc đơn giản là nhìn thấy một cái gì đó mới từ một số đệ trình khác!

Đây là liên kết để chạy thử! (TIO)

Một nửa trong

Bot này luôn trả giá một nửa những gì nó còn lại, ngoại trừ trong vòng cuối cùng, nơi nó sẽ đi vào tất cả.

class half_in:
  def __init__(self):
    self.money = 0
    self.round = -1
  def play_round(self, winner, win_amount):
    # Default actions:
    #  Collect 500 dollars
    self.money += 500
    #  If it was the winner: subtract the win_amount from his money
    if winner == 0:
      self.money -= win_amount
    #  One round further
    self.round += 1

    # If it's the final round: bid all in
    if self.round == 9:
      return self.money
    # Else: Bid half what it has left:
    return self.money / 2

Tôi không bao giờ lập trình bằng Python, vì vậy nếu bạn thấy bất kỳ lỗi nào hãy cho tôi biết ..

Danh sách xám

class Graylist:
  def __init__(self):
    self.round = 0
    self.player_money = [0] * 4
    self.ratios = {1}
    self.diffs = {0}
  def play_round(self, winner, winning_bid):
    self.round += 1
    if winner != -1:
      if winner >0 and winning_bid>0:
        self.ratios.add(self.player_money[winner]/winning_bid)
        self.diffs.add(self.player_money[winner]-winning_bid)
      self.player_money[winner] -= winning_bid
    self.player_money = [x+500 for x in self.player_money]
    tentative_bid = min(self.player_money[0],max(self.player_money[1:])+1, winning_bid+169, sum(self.player_money[1:])//3+169)
    while tentative_bid and (tentative_bid in (round(m*r) for m in self.player_money[1:] for r in self.ratios)) or (tentative_bid in (m-d for m in self.player_money[1:] for d in self.diffs)):
      tentative_bid = tentative_bid - 1
    return tentative_bid

Lấy cảm hứng từ việc đệ trình danh sách đen của histocrat , bot này ghi nhớ tất cả các cược thắng trước đó của những người chơi khác về cả tỷ lệ tiền họ đặt cược so với toàn bộ tiền của họ và chênh lệch giữa số tiền đặt cược của họ và toàn bộ số tiền. Để tránh thua trận hòa (dường như thực sự là một yếu tố lớn trong cuộc thi này), sau đó tránh đặt cược bất kỳ con số nào có thể đưa ra kết quả tương tự với số tiền hiện tại của đối thủ.

EDIT: là giá trị khởi đầu cho giá thầu hiện sử dụng mức tối thiểu giữa: tiền hiện tại của nó, nhiều hơn 1 so với tiền của đối thủ giàu nhất, X nhiều hơn so với đặt cược thắng cuối cùng, hoặc Y nhiều hơn tiền trung bình của đối thủ. X và Y là các hằng số có thể sẽ được sửa đổi trước khi kết thúc cuộc thi.

AverageMine

Người chơi này tính tỷ lệ phần trăm (giá thầu / tổng tiền) cho người chiến thắng của mỗi vòng và trả giá (tổng tiền * tỷ lệ thắng trung bình + 85) trừ khi anh ta có nhiều tiền hơn tất cả những người chơi khác, sau đó anh ta trả giá cao hơn 1 so với đối thủ cao nhất . Bắt đầu với giá thầu 99,0% số tiền bắt đầu.

class AverageMine:
    nplayers = 4
    maxrounds = 10
    def __init__(self):
        self.money = [0] * self.nplayers
        self.wins = [0] * self.nplayers
        self.round = 0
        self.average = 0
    def play_round(self, winner, win_amt):
        self.round += 1
        for i in range(self.nplayers):
            if i == winner:
                self.average = (self.average * (self.round - 2) + (win_amt / self.money[i])) / (self.round - 1)
                self.money[i] -= win_amt
                self.wins[i] += 1
            self.money[i] += 500
        if self.round == 1:
            return int(0.990 * self.money[0])
        elif self.round < self.maxrounds:
            if self.money[0] > self.money[1] + 1 and self.money[0] > self.money[2] + 1 and self.money[0] > self.money[3] + 1:
                return max(self.money[1],self.money[2],self.money[3]) + 1
            bid = int(self.average * self.money[0]) + 85
            return min(self.money[0],bid)
        else:
            bid = self.money[0]
            return bid

Eenie Nghĩa

Người chơi này giống hệt với Meanie, ngoại trừ một biến. Phiên bản này đấu thầu mạnh mẽ hơn và khiến một số người chơi chi tiêu nhiều hơn so với ý kiến ​​cho rằng đấu giá là có giá trị.

class eenie_meanie_more:
    def __init__(self):
        self.money = [0] * 4
        self.rounds = 11
        self.total_spent = 0

    def play_round(self, winner, winning_bid):
        self.money = [x+500 for x in self.money]
        self.rounds -= 1
        if winner != -1:
            self.money[winner] -= winning_bid
            self.total_spent += winning_bid
        bid = 500
        if self.rounds > 0 and self.total_spent < 20000:
            bid = int((20000 - self.total_spent)/self.rounds/4)+440
        return min(bid, max(self.money[1:])+1, self.money[0])

Nhà phân phối

Khi bot này thua một vòng, anh ta phân phối tiền thừa trong số tất cả các vòng tiếp theo. Anh ta đặt $ 499 vào vòng đầu tiên với suy nghĩ rằng những người khác sẽ ràng buộc với $ 500 và bị loại.

class distributer:
  def __init__(self):
    self.money = 0
    self.rounds = 11
  def play_round(self, winner, amt):
    self.money += 500
    self.rounds -= 1
    if self.rounds == 10:
      return 499
    if winner == 0:
      self.money -= amt
    return ((self.rounds - 1) * 500 + self.money) / self.rounds

Nghĩa

Người chơi này lấy tổng số tiền sẽ tham gia chơi để nhận được giá thầu trung bình trên số lượng người chơi và các vòng còn lại. Nếu mục tiêu này nhiều hơn tất cả những người chơi khác hiện đang giữ thì nó sẽ hạ giá thầu xuống mức cân bằng của đối thủ cạnh tranh lớn nhất cộng với một. Nếu người chơi không thể đủ khả năng cho mục tiêu của mình, thì đó là tất cả.

class meanie:
    def __init__(self):
        self.money = [0] * 4
        self.rounds = 11
        self.total_spent = 0

    def play_round(self,winner,winning_bid):
        self.money = [x+500 for x in self.money]
        self.rounds -= 1
        if winner != -1:
            self.money[winner] -= winning_bid
            self.total_spent += winning_bid
        bid = 500
        if self.rounds > 0 and self.total_spent < 20000:
            bid = int((20000 - self.total_spent)/self.rounds/4)+1
        return min(bid,max(self.money[1:])+1,self.money[0])

Đánh bại người chiến thắng

Trả giá nhiều hơn 1 người chơi có nhiều chiến thắng nhất cho đến nay

class BeatTheWinner:
    nplayers = 4
    maxrounds = 10
    def __init__(self):
        self.money = [0] * self.nplayers
        self.wins = [0] * self.nplayers
        self.round = 0

    def play_round(self, winner, win_amt):
        self.round += 1
        for i in range(self.nplayers):
            self.money[i] += 500
            if i == winner:
                self.money[i] -= win_amt
                self.wins[i] += 1
        mymoney = self.money[0]
        for w,m in sorted(zip(self.wins, self.money),reverse=True):
            if mymoney > m:
                return m+1
        #if we get here we can't afford our default strategy, so
        return int(mymoney/10)

Trừ đi một

class minus_one:
    def __init__(self):
        self.money = 0
    def play_round(self, winner, amount):
        self.money += 500
        if winner == 0:
            self.money -= amount
        return self.money - 1

Trả giá cao hơn

class bid_higher:
    def __init__(self):
        self.dollar = 0
        self.round = 0
    def play_round(self, winner, win_amount):
        self.dollar += 500
        self.round += 1
        inc = 131
        if winner == 0: self.dollar -= win_amount
        if self.round == 10: return self.dollar
        if win_amount == 0: win_amount = 500
        if self.dollar > (win_amount + inc):
            return win_amount + inc
        else:
            if self.dollar > 1:
                return self.dollar -1
            else:
                return 0

Vẫn đang học trăn; trả giá cao hơn một chút so với người chiến thắng cuối cùng.

FiveFiveFive

Bỏ qua vòng đầu tiên và trả giá $ 555 cho các vòng còn lại. Trong vòng cuối cùng, sẽ đi tất cả vào trừ khi 2 bot khác có cùng số tiền (và có lẽ sẽ ràng buộc).

class FiveFiveFive:
    nplayers = 4
    maxrounds = 10
    def __init__(self):
        self.money = [0] * self.nplayers
        self.wins = [0] * self.nplayers
        self.round = 0

    def play_round(self, winner, win_amt):
        self.round += 1
        for i in range(self.nplayers):
            self.money[i] += 500
            if i == winner:
                self.money[i] -= win_amt
                self.wins[i] += 1
        if self.round == 1:
            return 0
        elif self.round < self.maxrounds:
            return min(555, self.money[0])
        else:
            bid = self.money[0]
            return bid if self.money.count(bid) < 3 else bid-1

Hầu như tất cả trong

class Almost_All_In:
	def __init__(self):
		self.money = 0
		self.round = 0
	def play_round(self, loser, bid):
		self.money += 500 - (not loser) * bid
		self.round += 1
		return self.money - self.round % 3 * 3 - 3

Luôn trả giá thấp hơn một chút so với nó có.

Nâng cao nhanh chóng

Giá thầu tăng phân số tiền của nó mỗi vòng (vui lòng cho tôi biết nếu có lỗi, một thời gian kể từ khi tôi sử dụng Python)

class escalating:
  def __init__(self):
    self.money = 0
    self.round = 0
  def play_round(self, winner, win_amount):
    # Default actions:
    #  Collect 500 dollars
    self.money += 500
    #  If it was the winner: subtract the win_amount from his money
    if winner == 0:
      self.money -= win_amount
    #  One round further
    self.round += 1

    # bid round number in percent times remaining money, floored to integer
    return self.money * self.round // 10

Dưới mức trung bình

Tương tự như trên trung bình, nhưng đi thấp hơn một chút

class below_average:
  def __init__(self):
    self.round = 0
    self.player_money = [0] * 4
  def play_round(self, winner, winning_bid):
    self.round += 1
    self.player_money = [x+500 for x in self.player_money]
    if winner != -1:
      self.player_money[winner] -= winning_bid
    if self.round == 10:
      return self.player_money[0]
    bid = sum(self.player_money[1:]) / 3 - 2
    if bid > self.player_money[0]:
      return self.player_money[0]
    return min(self.player_money[0], bid)

Con ngựa cao

Người chơi này trả giá tất cả số tiền của anh ta trừ đi số vòng hiện tại, ngoại trừ vòng cuối cùng, nơi anh ta đi vào.

class HighHorse:
    maxrounds = 10
    def __init__(self):
        self.money = 0
        self.round = 0
    def play_round(self, winner, win_amt):
        self.round += 1
        if 0 == winner:
            self.money -= win_amt
        self.money += 500
        if self.round < self.maxrounds:
            return self.money - self.round
        else:
            bid = self.money
            return bid

Hoán đổi

Thay thế giữa đấu thầu một dưới mức tối đa của mình và tất cả trong.

class Swapper:
    def __init__(self):
        self.money = 0
        self.round = 0
    def play_round(self, loser, bid):
        self.money += 500 - (not loser) * bid
        self.round += 1
        if self.round & 1:
            return self.money - 1
        return self.money

Tôi hình dung mình cần tìm thứ gì đó có thể đánh bại minus_one của Steadybox. :)

Danh sách đen mô-đun

class blacklist_mod:
  def __init__(self):
    self.round = 0
    self.player_money = [0] * 4
    self.blacklist = {0, 499}
  def play_round(self, winner, winning_bid):
    self.round += 1
    self.player_money = [x+500 for x in self.player_money]
    if winner != -1:
      self.player_money[winner] -= winning_bid
      self.blacklist.add(winning_bid % 500)
      self.blacklist |= {x % 500 for x in self.player_money[1:]}
    tentative_bid = self.player_money[0]
    autowin = max(self.player_money[1:])+1
    if tentative_bid < autowin:
      while tentative_bid and (tentative_bid % 500) in self.blacklist:
        tentative_bid = tentative_bid - 1
    else:
      tentative_bid = autowin
    self.blacklist.add(tentative_bid % 500)
    return tentative_bid

Đặt cược số tiền cao nhất có thể không phù hợp với modulo 500 cho bất kỳ số nào đã thấy trước đó.

Chỉnh sửa để không áp dụng danh sách đen khi nó có thể có được một chiến thắng được đảm bảo.

Heurist

Các Heurist đối xử với trò chơi này là một trong những khả năng lặp lại, vì vậy nó biết nơi để vẽ đường.

Nó cũng là tồi tệ, vì vậy nó trả giá tối thiểu cần thiết cho một chiến thắng khi có thể.

class heurist:
    def __init__(self):
        self.money = 0
        self.round = -1
        self.net_worth = [0] * 4
    def play_round(self, winner, bid):
        self.round += 1
        self.money += 500
        if winner == 0: self.money -= bid
        if winner != -1: self.net_worth[winner] -= bid
        self.net_worth = [x+500 for x in self.net_worth]
        max_bid = [498,1000,1223,1391,1250,1921,2511,1666,1600,5000][self.round]
        if self.money > max_bid:
            return 1 + min(max_bid,max(self.net_worth[1:3]))
        else:
            return self.money

Tuyên bố từ chối trách nhiệm: max_bidcó thể thay đổi

bob_hater

Bot này không thích Bob và do đó sẽ luôn trả giá 2 đô la để giành chiến thắng trước Bob.

class bob_hater:
    def play_round(bob,will,loose):
        return 2

Khoe khoang

Đây là anh chàng thể hiện khả năng toán học của mình trong các tình huống thực sự không đòi hỏi bất cứ điều gì quá phức tạp. Cho đến vòng cuối cùng (trong đó anh ta tham gia tất cả), anh ta sử dụng mô hình logistic để xác định giá thầu của mình, hơn nữa nếu kẻ thù của anh ta còn lại một phần tiền lớn hơn.

class Showoff:
  def __init__(self):
      self.moneys = [0, 0, 0]
      self.roundsLeft = 10
  def play_round(self, winner, winning_bid):
      import math
      self.moneys = [self.moneys[0] + 500,
                     self.moneys[1] + 1500,
                     self.moneys[2] + 1500]
      self.roundsLeft -= 1
      if winner > 0:
          self.moneys[1] -= winning_bid
      if winner == 0:
          self.moneys[0] -= winning_bid
      if self.roundsLeft == 0:
          return self.moneys[0]
      ratio = self.moneys[1] / self.moneys[2]
      logisticized = (1 + (math.e ** (-8 * (ratio - 0.5)))) ** -1
      return math.floor(self.moneys[0] * logisticized)

Đường cong logistic được sử dụng là f (x) = 1 / (1 + e ^{-8 (x - 0,5)} ), trong đó x là tỷ lệ tiền của kẻ thù hiện tại so với tổng số tiền của kẻ thù tiềm năng. Những người khác càng có nhiều, anh ta trả giá càng nhiều. Điều này có lợi ích có thể của việc đấu thầu gần như nhưng không hoàn toàn là $ 500 trong vòng đầu tiên.

AntiMaxer

Phù hợp với số tiền cao nhất chúng tôi có thể chi trả cho tất cả tiền của người chơi. Sẽ khiến bất kỳ bot nào tham gia vào vòng đấu đó.

class AntiMaxer:
    nplayers = 4
    maxrounds = 10
    def __init__(self):
        self.money = [0] * self.nplayers
        self.wins = [0] * self.nplayers
        self.round = 0

    def play_round(self, winner, win_amt):
        self.round += 1
        for i in range(self.nplayers):
            self.money[i] += 500
            if i == winner:
                self.money[i] -= win_amt
                self.wins[i] += 1
        return max((m for m in self.money[1:] if m<=self.money[0]),
                   default=0)    

Bot đơn giản

class simple_bot:
    def __init__(self):
        self.round = 0
        self.money = 0
    def rand(self, seed, max):
        return (394587485 - self.money*self.round*seed) % (max + 1)
    def play_round(self, winner, amount):
        self.round += 1
        self.money += 500
        if winner == 0:
            self.money -= amount
        bid = 980 + self.rand(amount, 135)
        if self.money < bid or self.round == 10:
            bid = self.money
        return bid

Gần giống như Bệnh nhân Bot, nhưng không phải là bệnh nhân. Nhận được một số điểm tốt hơn nhiều so với nó, mặc dù.

Wingman 2

Nếu một wingman là tốt, hai phải tốt hơn?

class wingman_2:
    def __init__(self):
        self.dollar = 0
        self.round = 0
    def play_round(self, winner, win_amount):
        self.round += 1
        self.dollar += 500
        inc = 129
        if win_amount == 0: win_amount = 500
        if winner == 0: self.dollar -= win_amount
        if self.round == 10: return self.dollar
        if self.dollar > win_amount + inc:
            return win_amount + inc
        else:
            if self.dollar > 1: return self.dollar -1
            else:
                return 0