Trong thử thách này, bạn sẽ vào vai tình huống khó xử lặp đi lặp lại của tù nhân ồn ào.

Tình thế tiến thoái lưỡng nan của tù nhân là một kịch bản trong lý thuyết trò chơi, nơi có hai người chơi, mỗi người có hai lựa chọn: hợp tác hoặc khiếm khuyết. Mỗi người chơi sẽ làm điều tốt hơn cho chính họ nếu họ đào tẩu hơn là hợp tác, nhưng cả hai người chơi sẽ thích kết quả mà cả hai người chơi hợp tác với người mà cả hai người chơi đều khiếm khuyết.

Tình huống khó xử của tù nhân lặp đi lặp lại là cùng một trò chơi, ngoại trừ bạn chơi với cùng một đối thủ nhiều lần và bạn biết đối thủ của mình đã chơi gì trong quá khứ. Mục tiêu của bạn là luôn tích lũy điểm số cao nhất cho bản thân, bất kể đối thủ của bạn làm thế nào.

Tình trạng khó xử lặp đi lặp lại ồn ào của tù nhân giới thiệu một số tiếng ồn vào giao tiếp. Kiến thức của bạn về những gì đối thủ của bạn đã chơi trong quá khứ sẽ có một số tiếng ồn được giới thiệu. Bạn cũng sẽ biết những gì bạn đã thực hiện trong quá khứ. Tốc độ tiếng ồn không đổi trong một vòng so với cùng một đối thủ, nhưng khác nhau giữa các vòng khác nhau.

Thử thách

Trong thử thách này, bạn sẽ viết một chương trình Python 3 để chơi trò tiến thoái lưỡng nan của tù nhân ồn ào.

Chương trình của bạn sẽ nhận được ba đầu vào:

• Di chuyển của riêng bạn, không áp dụng lật ngẫu nhiên.

• Di chuyển của đối thủ của bạn, với lật ngẫu nhiên được áp dụng.

• Một biến trạng thái, bắt đầu như một danh sách trống mỗi vòng và bạn có thể sửa đổi nếu muốn. Bạn có thể bỏ qua điều này nếu bạn không muốn sử dụng nó.

Chương trình của bạn nên xuất ra 'c'để hợp tác hoặc 'd'để sửa lỗi.

Chẳng hạn, đây là một chương trình hợp tác nếu đối thủ đã hợp tác ít nhất 60% thời gian trong quá khứ, sau khi các lần lật ngẫu nhiên được áp dụng và trong 10 lần lật đầu tiên:

def threshold(my_plays, their_flipped_plays, state):
    if len(their_flipped_plays) < 10:
        return 'c'
    opp_c_freq = their_flipped_plays.count('c')/len(their_flipped_plays)
    if opp_c_freq > 0.6:
        return 'c'
    else:
        return 'd'

Nếu bạn không biết Python, hãy viết bài đăng của bạn bằng mã giả và ai đó (tôi hoặc thành viên khác của trang web) có thể tạo chương trình Python tương ứng.

Trò chơi

Người chạy giải đấu có thể được tìm thấy ở đây: trò chơi ồn ào . Chạy noisy-game.pyđể chạy giải đấu. Tôi sẽ giữ cho kho lưu trữ được cập nhật với các bài nộp mới. Chương trình ví dụ có thể được tìm thấy trong basic.py.

Điểm tổng thể của một chương trình là tổng số điểm của nó trên 100 lượt chơi.

Một trò chơi bao gồm các trận đấu vòng tròn của mỗi người chơi với mỗi người chơi, bao gồm cả chính nó. Một trận đấu bao gồm 100 vòng. Một vòng bao gồm 300 di chuyển, mỗi bước bao gồm đầu ra 'c'hoặc 'd'.

Bài dự thi của bạn sẽ diễn ra một trận đấu với mọi bài dự thi, bao gồm bài của bạn. Mỗi trận đấu sẽ bao gồm 100 vòng. Trong mỗi vòng, xác suất lật sẽ được chọn ngẫu nhiên từ [0, 0.5].

Mỗi vòng sẽ bao gồm 300 di chuyển. Trong mỗi lần di chuyển, cả hai chương trình sẽ nhận được tất cả các lần phát trước mà chúng đã thử và tất cả các lần phát trước mà chương trình khác đã thực hiện, sau khi lật được áp dụng và một biến trạng thái, là danh sách có thể thay đổi mà chương trình có thể sửa đổi nếu muốn. Các chương trình sẽ xuất ra di chuyển của họ.

Di chuyển được ghi như sau: Nếu một chương trình chơi một 'c', chương trình đối lập được 2 điểm. Nếu một chương trình phát một 'd', chương trình đó được 1 điểm.

Sau đó, mỗi lần di chuyển được lật độc lập với xác suất bằng xác suất lật và được lưu trữ để hiển thị cho đối thủ.

Sau khi tất cả các vòng đã được chơi, chúng tôi tổng số điểm mỗi người chơi có được trong mỗi trận đấu. Sau đó, chúng tôi sử dụng hệ thống tính điểm sau để tính điểm của từng người chơi cho trò chơi. Việc ghi điểm này được thực hiện sau khi tất cả các trận đấu kết thúc.

Chấm điểm

Chúng tôi sẽ sử dụng tính điểm tiến hóa. Mỗi chương trình bắt đầu với trọng lượng bằng nhau. Sau đó, các trọng số được cập nhật như sau, trong 100 lần lặp, sử dụng tổng số điểm từ trò chơi:

Trọng lượng mới của mỗi chương trình tỷ lệ thuận với sản phẩm của trọng lượng trước đó và tổng điểm trung bình của nó, được cân bằng trọng lượng của đối thủ.

100 bản cập nhật như vậy được áp dụng và các trọng số cuối cùng là điểm số của mỗi chương trình cho lần chạy đó của trò chơi.

Điểm tổng thể sẽ là tổng số hơn 100 lượt chơi.

Người chơi sẽ có tất cả các câu trả lời hợp lệ cho thử thách này, cộng với sáu chương trình cơ bản để giúp chúng tôi bắt đầu.

Hãy cẩn thận

Không sửa đổi các đầu vào. Không cố gắng ảnh hưởng đến việc thực hiện bất kỳ chương trình nào khác, ngoại trừ thông qua hợp tác hoặc đào thoát. Không thực hiện một đệ trình hy sinh mà cố gắng nhận ra một đệ trình khác và mang lại lợi ích cho đối thủ bằng chi phí riêng của mình. Sơ hở tiêu chuẩn bị cấm.

EDIT: Đệ trình có thể không trùng lặp chính xác bất kỳ chương trình cơ bản hoặc bất kỳ đệ trình trước đó.

Nếu bạn có bất kỳ câu hỏi, hãy hỏi.

Kết quả hiện tại

nicht_genug: 40.6311
stealer: 37.1416
enough: 14.4443
wait_for_50: 6.947
threshold: 0.406784
buckets: 0.202875
change_of_heart: 0.0996783
exploit_threshold: 0.0670485
kickback: 0.0313357
tit_for_stat: 0.0141368
decaying_memory: 0.00907645
tit_for_whoops: 0.00211803
slider: 0.00167053
trickster: 0.000654875
sounder: 0.000427348
tit_for_tat: 9.12471e-05
stubborn_stumbler: 6.92879e-05
tit_for_time: 2.82541e-05
jedi2sith: 2.0768e-05
cooperate: 1.86291e-05
everyThree: 1.04843e-05
somewhat_naive: 4.46701e-06
just_noise: 1.41564e-06
growing_distrust: 5.32521e-08
goldfish: 4.28982e-09
vengeful: 2.74267e-09
defect: 3.71295e-10
alternate: 2.09372e-20
random_player: 6.74361e-21

Kết quả chỉ có câu trả lời cho câu hỏi này và các chương trình cơ bản bỏ qua lối chơi của đối thủ:

nicht_genug: 39.3907
stealer: 33.7864
enough: 20.9032
wait_for_50: 5.60007
buckets: 0.174457
kickback: 0.0686975
change_of_heart: 0.027396
tit_for_stat: 0.024522
decaying_memory: 0.0193272
tit_for_whoops: 0.00284842
slider: 0.00153227
sounder: 0.000472289
trickster: 0.000297515
stubborn_stumbler: 3.76073e-05
cooperate: 3.46865e-05
tit_for_time: 2.42263e-05
everyThree: 2.06095e-05
jedi2sith: 1.62591e-05
somewhat_naive: 4.20785e-06
just_noise: 1.18372e-06
growing_distrust: 6.17619e-08
vengeful: 3.61213e-09
goldfish: 3.5746e-09
defect: 4.92581e-10
alternate: 6.96497e-20
random_player: 1.49879e-20

Chiến thắng

Cuộc thi sẽ mở vô thời hạn, vì các bài nộp mới được đăng. Tuy nhiên, tôi sẽ tuyên bố một người chiến thắng (chấp nhận câu trả lời) dựa trên kết quả 1 tháng sau khi câu hỏi này được đăng.

Genug ist nicht genug

(cũng có thể được gọi enough2hoặc stealback)

def nicht_genug(m,t,s):
    if not s:
        s.append("c")
        return "c"
    if s[0]=="t":
        return "d"
    if m[-42:].count("d")>10 or len(t)+t.count("d")>300:
        s[0]="t"
        return "d"
    if t[-1]=="d":
        if s[0]=="d":
            s[0]="c"
            return "d"
        else:
            s[0]="d"
            return "c"
    else:
        if t[-3:].count("d")==0:
            s[0]="c"
        return "c"

Tôi đã học được rằng các tiêu chuẩn ban đầu cho hai tats đã chờ đợi hai tats liên tiếp như tit_for_whoopsvậy, và thực sự có vẻ như chúng ta nên tha thứ và quên (tốt, gần như ...) các tats đơn trước đó. Và rất nhiều người chơi khiếm khuyết trong các vòng cuối cùng. Tôi vẫn thích trở nên tốt đẹp khi mọi thứ đều ổn cho đến nay, nhưng thanh dung sai của bot cứ giảm dần.

Tit-For-Whoops

Lấy cảm hứng từ một chiến lược từ ncase.me/trust

def tit_for_whoops(m, t, s):
    if len(t) < 2:
        return 'c'
    else:
        return 'd' if all([x == 'd' for x in t[-2:]]) else 'c'

Khiếm khuyết chỉ khi người chơi khác đã đào thoát hai lần liên tiếp, để tránh hiểu lầm.

Thay lòng

def change_of_heart(m, t, s):
    return 'c' if len(t) < 180 else 'd'

Có một sự thay đổi của trái tim giữa chừng. Làm tốt đáng ngạc nhiên.

Chiến lược đánh cắp

Lấy cảm hứng từ đủ, change_of_love và ăn miếng trả miếng. Nên tha thứ hơn một chút. Tôi đã cố gắng điều chỉnh các con số để có kết quả tốt nhất nhưng chúng không muốn thay đổi nhiều.

def stealer(mine, theirs, state):
    if len(mine) == 0:
        state.append('c')
        return 'c'
    elif len(mine) > 250:
        return "d"
    elif state[0] == 't':
        return 'd'
    elif mine[-40:].count('d') > 10:
        state[0] = 't'
        return 'd'
    elif theirs[-1] == 'd':
        if state[0] == 'd':
            state[0] = 'c'
            return 'd'
        else:
            state[0] = 'd'
            return 'c'
    elif all([x == 'c' for x in theirs[-3:]]):
        state[0] = 'c'
        return 'c'
    else:
        return 'c'

Tit-For-Time

def tit_for_time(mine, theirs, state):
    theirs = theirs[-30:]
    no_rounds = len(theirs)
    return "c" if no_rounds < 5 or random.random() > theirs.count("d") / no_rounds else "d"

Nếu bạn dành phần lớn thời gian để làm tổn thương tôi, tôi sẽ chỉ làm bạn đau trở lại. Có lẽ.

Không tin tưởng

import random

def growing_distrust(mine, theirs, state):
    # Start with trust.
    if len(mine) == 0:
        state.append(dict(betrayals=0, trust=True))
        return 'c'

    state_info = state[0]

    # If we're trusting and we get betrayed, trust less.
    if state_info['trust'] and theirs[-1] == 'd':
        state_info['trust'] = False
        state_info['betrayals'] += 1

    # Forgive, but don't forget.
    if random.random() < 0.5 ** state_info['betrayals']:
        state_info['trust'] = True

    return 'c' if state_info['trust'] else 'd'

Đối thủ càng phản bội tôi, tôi càng không thể tin đó chỉ là tiếng ồn.

Jedi2Sith

Bắt đầu tất cả tốt đẹp và vị tha, nhưng theo thời gian, ảnh hưởng của mặt tối ngày càng mạnh mẽ hơn, cho đến khi không còn trở lại. Không thể ngăn chặn ảnh hưởng này, nhưng tất cả những điều tồi tệ mà nó thấy xảy ra chỉ góp phần tạo nên sức mạnh của mặt tối ...

def jedi2sith(me, them, the_force):
  time=len(them)
  bad_things=them.count('d')
  dark_side=(time+bad_things)/300
  if dark_side>random.random():
    return 'd'
  else:
    return 'c'

Hãy thử trực tuyến!

Thanh trượt

def slider(m, t, s):
    z = [[2, 1], [0, 1], [2, 3], [2, 1]]
    x = 0
    for y in t:
      x = z[x][y == 'c']
    return 'c' if x < 2 else 'd'

Bắt đầu với 'c', và dần dần trượt về phía hoặc ra khỏi 'd'.

Kẻ bướng bỉnh

def stubborn_stumbler(m, t, s):
    if not t:
        s.append(dict(last_2=[], last_3=[]))
    if len(t) < 5:
        return 'c'
    else:
        # Records history to state depending if the last two and three
        # plays were equal
        s = s[0]
        if t[-2:].count(t[-1]) == 2:
            s['last_2'].append(t[-1])
        if t[-3:].count(t[-1]) == 3:
            s['last_3'].append(t[-1])
    c_freq = t.count('c')/len(t)
    # Checks if you've consistently defected against me
    opp_def_3 = s['last_3'].count('d') > s['last_3'].count('c')
    opp_def_2 = s['last_2'].count('d') > s['last_2'].count('c')
    # dist func from 0 to 1
    dist = lambda x: 1/(1+math.exp(-5*(x-0.5)))
    # You've wronged me too much
    if opp_def_3 and opp_def_2:
        return 'd'
    # Otherwise, if you're consistently co-operating, co-operate more
    # the less naive you are
    else:
        return 'c' if random.random() > dist(c_freq) - 0.5 else 'd'

Dựa trên chiến lược ngưỡng khai thác của bạn chỉ với các lần phát nhất quán được theo dõi để chuyển đổi giữa lỗi và chủ yếu là hợp tác

CẬP NHẬT: Theo dõi cả hai lần chơi liên tiếp và ba lần liên tiếp, chỉ phạt trong điều kiện khắc nghiệt hơn và thêm một lựa chọn ngẫu nhiên khi không chắc chắn

CẬP NHẬT 2: Loại bỏ điều kiện và thêm chức năng phân phối

Tiếng ồn Bot

def just_noise(m,t,s):
    return 'c' if random.random() > .2 else 'd'

Tôi chắc chắn hợp tác bot. Đó chỉ là tiếng ồn.

Đủ là đủ

def enough(m,t,s):
    if not s:
        s.append("c")
        return "c"
    if s[0]=="t":
        return "d"
    if m[-42:].count("d")>10:
        s[0]="t"
        return "d"
    if t[-1]=="d":
        if s[0]=="d":
            s[0]="c"
            return "d"
        else:
            s[0]="d"
            return "c"
    else:
        return "c"

Bắt đầu như một miếng mồi ngon cho hai con hổ trong đó hai con hổ không phải liên tiếp (không giống nhau tit_for_whoops). Nếu nó phải chơi dquá thường xuyên, nó đi d-total.

Bot cá vàng

def goldfish(m,t,s):
    return 'd' if 'd' in t[-3:] else 'c'

Một con cá vàng không bao giờ tha thứ, nhưng nó nhanh chóng quên đi.

kẻ lừa bịp (phục hồi lại)

Chỉ có 10 vở kịch cuối cùng được tính, nhưng được chia thành hai khối năm, được tính trung bình với mỗi lần được phân loại là tốt hoặc xấu.

Nếu đối thủ chơi trung bình "đẹp", kẻ lừa đảo chơi càng ngày càng kém. Nếu kết quả không rõ ràng, kẻ lừa đảo chơi đẹp để dụ đối thủ vào chỗ an toàn. Nếu đối thủ có vẻ đang chơi "xấu" thì kẻ lừa đảo sẽ trả đũa.

Ý tưởng là thu thập điểm ngay bây giờ và sau đó từ những người chơi ngây thơ, trong khi bắt những kẻ lừa dối sớm.

import random
def trickster(player,opponent,state):
    pBad = 0.75
    pNice = 0.8
    pReallyBad =0.1
    decay = 0.98
    r = random.random()

    if len(player)<20: #start off nice
        return 'c' 
    else: #now the trickery begins
        last5 = opponent[-5:].count('c')/5.0 > 0.5
        last5old = opponent[-10:-5].count('c')/5.0  > 0.5
        if last5 and last5old: #she is naive, punish her
            pBad = pBad*decay #Increase punishment
            if r<pBad:
                return 'c'
            else:
                return 'd'
        elif last5 ^ last5old: #she is changing her mind, be nice!
            if r<pNice:
                return 'c'
            else:
                return 'd'
        else: #she's ratting you out, retaliate
            pReallyBad = pReallyBad*decay #Retaliate harder
            if r<pReallyBad:
                return 'c'
            else:
                return 'd'

Tuyên bố miễn trừ trách nhiệm: Tôi chưa bao giờ đăng ở đây trước đây, nếu tôi đang làm gì đó sai> xin vui lòng cho tôi biết và tôi sẽ sửa.

Ký ức suy tàn

def decaying_memory(me, them, state):
    m = 0.95
    lt = len(them)

    if not lt:
        state.append(0.0)
        return 'c'

    # If it's the last round, there is no reason not to defect
    if lt >= 299: return 'd'

    state[0] = state[0] * m + (1.0 if them[-1] == 'c' else -1.0)

    # Use a gaussian distribution to reduce variance when opponent is more consistent
    return 'c' if lt < 5 or random.gauss(0, 0.4) < state[0] / ((1-m**lt)/(1-m)) else 'd'

Cân nhắc lịch sử gần đây nhiều hơn. Từ từ quên đi quá khứ.

Khởi động lại

def kickback(m, t, s):
  if len(m) < 10:
    return "c"
  td = t.count("d")
  md = m.count("d")
  f = td/(len(t)+1)
  if f < 0.3:
    return "d" if td > md and random.random() < 0.1 else "c"
  return "c" if random.random() > f+2*f*f else "d"

Một số ý tưởng mơ hồ ...

Không thực sự có được toàn bộ "tiếng ồn"

def vengeful(m,t,s):
    return 'd' if 'd' in t else 'c'

Không bao giờ tha thứ cho một kẻ phản bội.

âm thanh:

chỉnh sửa: trả đũa thêm trong các tình huống có thể tiếng ồn thấp

về cơ bản, nếu cả 4 động tác đầu tiên đều hợp tác, điều đó có nghĩa là chúng ta sẽ mong đợi ít tiếng ồn hơn bình thường. khiếm khuyết một chút thường xuyên để bù cho những điểm ít hơn chúng ta sẽ nhận được từ việc không bao giờ đào thoát, và nó có thể bị đổ lỗi cho tiếng ồn. chúng tôi cũng trả đũa nếu họ khiếm khuyết chống lại chúng tôi

nếu đối thủ của chúng ta thực hiện nhiều khuyết điểm trong các lượt đó (2 hoặc nhiều hơn), chúng ta sẽ đào tẩu trở lại với họ. nếu đó chỉ là tiếng ồn, thì tiếng ồn sẽ ảnh hưởng đến việc di chuyển của chúng ta.

mặt khác, nếu chỉ có 1 động tác là khiếm khuyết, chúng tôi chỉ thực hiện các thao tác đơn giản cho phần còn lại của trò chơi.

def sounder(my, their, state):
    if len(my)<4:
        if their.count("d")>1:
            return "d"
        return "c"
    elif len(my) == 4:
        if all(i == "c" for i in their):
            state.append(0)
            return "d"
        elif their.count("c") == 3:
            state.append(1)
            return "c"
        else:
            state.append(2)
    if state[0] == 2:
        return "d"
    if state[0] == 0:
        if not "d" in my[-4:]:
            return "d"
        return their[-1]
    else:
        return their[-1]

Luân phiên

def alternate(m, t, s):
    if(len(m)==0):
        return 'c' if random.random()>.5 else 'd'
    elif(len(m)>290):
        return 'd'
    else:
        return 'd' if m[-1]=='c' else 'c'

Chọn ngẫu nhiên trong vòng đầu tiên, sau đó luân phiên. Luôn khiếm khuyết trong 10 vòng cuối.

Đợi 50

def wait_for_50(m, t, s):
  return 'c' if t.count('d') < 50 else 'd'

Sau 50 lỗi, chúng ta hãy có nó!

Đôi khi ngây thơ

def somewhat_naive(m, t, s):
    p_flip = 0.25
    n = 10
    if len(t) < n:
        return 'c' if random.random() > p_flip else 'd'
    d_freq = t[-n:].count('d')/n
    return 'c' if d_freq < p_flip else 'd'

Tôi sẽ chỉ cho rằng nếu bạn đã đào thoát ít hơn xác suất lật (đại khái) trong n lượt cuối cùng , thì đó là tiếng ồn và không phải là ý bạn!

Không tìm ra n tốt nhất , có thể nhìn sâu hơn vào đó.

Mỗi ba

def everyThree(me,him,s):
    if len(me) % 3 == 2:
        return "d"
    if len(me) > 250:
        return "d"
    if him[-5:].count("d")>3:
        return "d"
    else:
        return "c"

Khiếm khuyết cứ sau ba lượt. Cũng khiếm khuyết trong 50 lượt cuối cùng. Cũng có khuyết điểm nếu đối thủ của anh đào thoát 4 trên 5 vòng đấu trước.

Xô

def buckets(m, t, s):
    if len(m) <= 5:
        return 'c'
    if len(m) >= 250:
        return 'd'
    d_pct = t[-20:].count('d')/len(t[-20:])
    if random.random() > (2 * d_pct - 0.5):
        return 'c'
    else:
        return 'd'

Chơi tốt để bắt đầu. Nhìn vào 20 cuối cùng của chúng, nếu <25% d, trả về c,> 75% d, trả về d và ở giữa chọn ngẫu nhiên dọc theo hàm xác suất tuyến tính. 50 cuối, khuyết điểm. Có điều này ở 10 cuối cùng nhưng đã thấy rất nhiều khiếm khuyết 50 cuối cùng.

Lần đầu tiên ở đây để cho tôi biết nếu một cái gì đó cần phải được sửa chữa (hoặc làm thế nào tôi có thể kiểm tra điều này).

Tit-For-Stat

Khiếm khuyết nếu đối thủ đã đào thoát hơn một nửa thời gian.

def tit_for_stat(m, t, s):
  if t.count('d') * 2 > len(m):
    return 'd'
  else:
    return 'c'