Dilema Tahanan Iterasi Tahanan

35

Dalam tantangan ini, Anda akan memainkan dilema tahanan yang diulang-ulang dan berisik.

The Dilema Tahanan adalah skenario dalam teori permainan di mana ada dua pemain, masing-masing dengan dua pilihan: bekerja sama, atau cacat. Setiap pemain melakukan lebih baik untuk diri mereka sendiri jika mereka cacat daripada jika mereka bekerja sama, tetapi kedua pemain akan lebih suka hasil di mana kedua pemain bekerja sama dengan yang di mana kedua pemain cacat.

Dilema tahanan yang diulang adalah permainan yang sama, kecuali Anda bermain melawan lawan yang sama berulang kali, dan Anda tahu apa yang telah dimainkan lawan Anda di masa lalu. Tujuan Anda adalah selalu mengumpulkan skor tertinggi untuk diri sendiri, terlepas dari bagaimana lawan Anda melakukannya.

Dilema narapidana yang bising dan berulang-ulang menimbulkan kebisingan dalam komunikasi. Pengetahuan Anda tentang apa yang telah dimainkan lawan Anda di masa lalu akan memiliki sedikit kebisingan. Anda juga akan tahu gerakan apa yang Anda lakukan di masa lalu. Tingkat kebisingan konstan pada putaran melawan lawan yang sama, tetapi berbeda antara putaran yang berbeda.

Tantangan

Dalam tantangan ini, Anda akan menulis sebuah program Python 3 untuk memainkan dilema narapidana iterated yang berisik.

Program Anda akan menerima tiga input:

  • Gerakan Anda sendiri, tanpa flips acak diterapkan.

  • Gerakan lawan Anda, dengan flips acak diterapkan.

  • Variabel status, yang dimulai sebagai daftar kosong setiap putaran, dan yang dapat Anda modifikasi jika diinginkan. Anda dapat mengabaikan ini jika Anda tidak ingin menggunakannya.

Program Anda harus menampilkan 'c'untuk bekerja sama atau 'd'cacat.

Misalnya, inilah program yang bekerja sama jika lawan telah bekerja sama setidaknya 60% dari waktu di masa lalu, setelah membalik acak diterapkan, dan untuk 10 membalik pertama:

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'

Jika Anda tidak tahu Python, tulis kiriman Anda dalam pseudocode, dan seseorang (saya atau anggota lain dari situs) dapat membuat program Python yang sesuai.

Gameplay

Pelari turnamen dapat ditemukan di sini: permainan berisik . Lari noisy-game.pyuntuk menjalankan turnamen. Saya akan menjaga repositori itu diperbarui dengan kiriman baru. Contoh program dapat ditemukan di basic.py.

Skor keseluruhan suatu program adalah total skornya lebih dari 100 permainan.

Sebuah permainan terdiri dari pertarungan round-robin dari setiap pemain melawan masing-masing pemain, termasuk dirinya sendiri. Sebuah pertarungan terdiri dari 100 putaran. Putaran terdiri dari 300 gerakan, yang masing-masing melibatkan keluaran 'c'atau 'd'.

Kiriman Anda akan memainkan pertarungan melawan setiap kiriman, termasuk milik Anda. Setiap pertandingan akan terdiri dari 100 putaran. Selama setiap putaran, probabilitas balik akan dipilih secara acak dari [0, 0.5].

Setiap putaran akan terdiri dari 300 gerakan. Pada setiap gerakan, kedua program akan menerima semua permainan sebelumnya yang telah mereka coba, dan semua permainan sebelumnya yang telah dibuat oleh program lain, setelah flips diterapkan, dan variabel status, yang merupakan daftar yang dapat diubah yang dapat diubah oleh program jika diinginkan. Program akan menampilkan gerakan mereka.

Bergerak diberi skor sebagai berikut: Jika suatu program memainkan 'c', program lawan mendapat 2 poin. Jika suatu program memainkan 'd', program itu mendapat 1 poin.

Kemudian, setiap gerakan dibalik secara independen dengan probabilitas sama dengan probabilitas balik, dan disimpan untuk ditunjukkan kepada lawan.

Setelah semua putaran dimainkan, kami menjumlahkan jumlah poin yang didapat setiap pemain dalam setiap pertandingan. Kemudian, kami menggunakan sistem penilaian berikut untuk menghitung skor setiap pemain untuk permainan. Skor ini dilakukan setelah semua pertandingan selesai.

Mencetak gol

Kami akan menggunakan skor evolusi. Setiap program dimulai dengan bobot yang sama. Kemudian, bobot diperbarui sebagai berikut, untuk 100 iterasi, menggunakan total poin dari game:

Bobot baru masing-masing program sebanding dengan produk dari bobot sebelumnya dan total poin rata-rata, ditimbang oleh bobot lawan-lawannya.

100 pembaruan semacam itu diterapkan, dan bobot terakhir adalah skor masing-masing program untuk permainan tersebut.

Skor keseluruhan akan menjadi jumlah lebih dari 100 kali permainan.

Para pemain akan menjadi semua jawaban yang valid untuk tantangan ini, ditambah enam program dasar untuk memulai.

Peringatan

Jangan memodifikasi input. Jangan mencoba untuk mempengaruhi pelaksanaan program lain, kecuali melalui bekerja sama atau membelot. Jangan membuat pengorbanan pengorbanan yang mencoba untuk mengakui pengajuan lain dan manfaat lawan itu dengan biaya sendiri. Celah standar dilarang.

EDIT: Kiriman mungkin tidak sama persis dengan duplikat program dasar atau pengajuan sebelumnya.

Jika Anda memiliki pertanyaan, jangan ragu untuk bertanya.

Hasil saat ini

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

Hasil dengan hanya jawaban untuk pertanyaan ini dan program dasar yang mengabaikan permainan lawan:

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

Kemenangan

Kompetisi akan tetap terbuka tanpa batas waktu, karena kiriman baru diposting. Namun, saya akan mengumumkan pemenang (menerima jawaban) berdasarkan hasil 1 bulan setelah pertanyaan ini diposting.

isaacg
sumber
Bagaimana tit_for_whoops mengabaikan permainan lawan?
LyricLy
@LyricLy Saya menganggap kategori mengacu pada program dasar yang disediakan oleh Isaac yang mengabaikan lawan mereka.
FryAmTheEggman
1
Apakah saya mengerti benar bahwa Anda dapat menggunakan variabel status untuk merekam semua gerakan Anda saat Anda mengirimkannya, dan oleh karena itu tahu gerakan Anda yang sebenarnya dan gerakan yang terbalik, serta memperkirakan probabilitas balik?
xnor
1
@ xnor Anda selalu diberi tahu gerakan Anda yang sebenarnya. Hanya gerakan lawan yang bisa terbalik.
1
@isaacg Saya mencoba menyalin exploit_threshold()beberapa kali exploit_threshold1(), dll dan menambahkannya ke playersdaftar. Mengapa saya mendapatkan hasil yang sangat berbeda untuk strategi yang identik?
ngn

Jawaban:

4

Genug ist nicht genug

(bisa juga disebut enough2atau 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"

Saya belajar bahwa tit asli untuk dua tats memang menunggu dua tats berturut-turut seperti tit_for_whoopshalnya, dan memang sepertinya kita harus memaafkan dan melupakan (well, hampir ...) single tats sebelumnya. Dan banyak pemain yang cacat di babak terakhir. Saya masih lebih suka bersikap baik ketika semuanya baik-baik saja sejauh ini, tetapi bar toleransi bot terus semakin rendah.

Sievers Kristen
sumber
11

Tit-Untuk-Whoops

Terinspirasi oleh strategi dari 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'

Cacat hanya jika pemain lain telah membelot dua kali berturut-turut, untuk mencegah kesalahpahaman.

Lirik
sumber
Terima kasih atas kiriman Anda! Perlu diingat bahwa karena probabilitas flip rata-rata 1/4, akan ada flip-ganda sekali setiap 16 gerakan atau lebih.
isaacg
Saya menambahkan variabel status, yang dapat Anda abaikan jika Anda tidak ingin menggunakannya.
isaacg
9

Perubahan perasaan

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

Memiliki perubahan hati setengah jalan. Ternyata sangat baik.

qwewqa
sumber
Selamat atas memimpin / tempat kedua. Saya terkesan dan terkejut bahwa lawan yang mengabaikan strategi berhasil dengan baik.
isaacg
9

Pencuri Strategi

Terinspirasi oleh cukup, change_of_heart, dan tit-for-whoops. Seharusnya sedikit lebih memaafkan. Saya mencoba mengubah angka untuk hasil terbaik tetapi mereka tidak ingin banyak berubah.

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'
Adebunk
sumber
selamat datang di PPCG!
Giuseppe
Selamat telah memimpin!
isaacg
8

Tit-Untuk-Waktu

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"

Jika Anda telah menghabiskan sebagian besar waktu menyakiti saya, saya hanya akan menyakiti Anda kembali. Mungkin.

Biru
sumber
Pengiriman yang bagus! Saat ini Anda berada di posisi pertama tanpa program dasar yang disadari oleh lawan.
isaacg
7

Tumbuhnya Ketidakpercayaan

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'

Semakin lawan mengkhianatiku, semakin aku tidak percaya itu hanya suara.


sumber
Ya, tidak ada hal negara yang disayangkan, tetapi saya ingin pengiriman menjadi seragam, jadi ini adalah yang terbaik yang bisa saya pikirkan. Apakah Anda punya ide tentang cara menambahkan negara?
isaacg
Punya stateargumen bahwa secara default daftar? Daftar bisa berubah, sehingga negara dapat dimodifikasi dengan mudah.
LyricLy
Bagaimana? Saya tidak mengerti bagaimana itu bisa terjadi.
LyricLy
@Mnemonic Saya rasa saya tahu bagaimana menerapkan ini. Saya akan berputar.
isaacg
Saya menambahkan variabel status, yang pada dasarnya adalah daftar kosong, dan yang dapat Anda modifikasi.
isaacg
7

Jedi2Sith

Mulai dari semua yang bagus dan tanpa pamrih, tetapi seiring waktu pengaruh sisi gelap tumbuh semakin kuat, sampai titik tanpa kembali. Tidak ada yang bisa menghentikan pengaruh ini, tetapi semua hal buruk yang dilihatnya terjadi hanya berkontribusi pada kekuatan sisi gelap ...

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'

Cobalah online!

Leo
sumber
6

Slider

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'

Mulai dengan 'c', dan secara bertahap meluncur ke arah atau menjauh dari 'd'.

mil
sumber
Saya melakukan penulisan ulang yang setara secara fungsional untuk menggunakan variabel status, karena itu berjalan cukup lambat. Namun, Anda tidak perlu mengubah apa pun.
isaacg
6

Stumbborn Stumbler

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'

Didasarkan pada strategi ambang eksploit Anda dengan hanya permainan yang konsisten terus melacak untuk beralih antara cacat dan sebagian besar bekerja sama

UPDATE: Melacak dua bermain berturut-turut dan tiga berturut-turut, hanya menghukum dalam kondisi yang lebih keras dan menambahkan pilihan acak ketika tidak yakin

UPDATE 2: Kondisi dihapus dan fungsi distribusi ditambahkan

JMigst
sumber
Selamat menulis program pertama untuk memimpin!
isaacg
6

Bot Kebisingan

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

Saya pasti bekerja sama bot. Itu hanya kebisingan.

Chris
sumber
6

Cukup sudah

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"

Mulai sebagai gayung untuk dua tats di mana dua tats tidak harus berturut-turut (tidak seperti tit_for_whoops). Jika harus bermain dterlalu sering, d-total.

Sievers Kristen
sumber
Selamat untuk memimpin!
isaacg
6

Bot Ikan Mas

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

Seekor ikan mas tidak pernah memaafkan, tetapi dengan cepat lupa.

Chris
sumber
6

penipu (diaktifkan kembali)

Hanya 10 drama terakhir yang dicatat, tetapi dibagi menjadi dua blok yang terdiri dari lima, yang dirata-ratakan dengan masing-masing diklasifikasikan sebagai baik atau buruk.

Jika lawan bermain rata-rata "baik", penipu bermain semakin sedikit. Jika hasilnya ambigu, si penipu bermain bagus untuk memikat lawan agar aman. Jika lawan tampak bermain "buruk", penipu membalas.

Idenya adalah untuk mengumpulkan poin sekarang dan kemudian dari pemain naif, sambil menangkap yang menipu lebih awal.

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'

Penafian: Saya belum pernah memposting di sini sebelumnya, jika saya melakukan sesuatu yang salah> tolong katakan padaku dan aku akan memperbaikinya.

Hektor-Waartgard
sumber
Selamat datang di situs ini! Sayangnya, kode Anda saat ini tidak berfungsi. Anda memiliki elif setelah yang lain. Bisakah Anda memperbaikinya? Terima kasih
isaacg
Saya menduga semuanya dari elif dan seterusnya harus indentasi sekali lagi?
isaacg
Benar, saya akan indentasi.
Hektor-Waartgard
@isaacg Saya telah memperbarui jawaban saya dengan kode baru. Saya tidak memiliki reputasi yang cukup untuk menceritakannya kepada Anda dalam pertanyaan-komentar. Saya tidak yakin bahwa saya menggunakan variabel keadaan dengan benar, saya menganggap itu adalah daftar kosong yang dapat saya tambahkan apa pun yang saya mau, benar?
Hektor-Waartgard
2
Itu tidak akan berhasil. Setelah setiap belokan, diputuskan apakah gerakan saat ini dibalik atau tidak (secara independen untuk kedua pemain). Keputusan itu kemudian diperbaiki. Anda akan selalu melihat langkah pertama yang sama yang mungkin terbalik atau tidak, tetapi itu tidak akan berubah.
Christian Sievers
5

Memori yang membusuk

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'

Menimbang lebih banyak riwayat terkini. Perlahan-lahan melupakan masa lalu.

qwewqa
sumber
5

Pembayaran kembali

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"

Beberapa ide yang kabur ...

Sievers Kristen
sumber
Selamat telah memimpin di versi mana mantra dasar adaptif dihapus.
isaacg
Terima kasih. Saya pikir itu luar biasa betapa berbedanya dua hasil!
Christian Sievers
4

Tidak Benar-Benar Mendapat Masalah "Kebisingan" Utuh

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

Jangan pernah memaafkan pengkhianat.

Chris
sumber
4

sounder:

sunting: menambahkan pembalasan dalam skenario dengan noise rendah

pada dasarnya, jika semua 4 langkah pertama bekerja sama, itu berarti kita harus mengharapkan lebih sedikit suara daripada biasanya. defect sedikit setiap sesekali untuk menebus poin yang lebih sedikit yang kita dapatkan dari tidak pernah membelot, dan membuatnya dapat disalahkan pada noise. kami juga membalas jika mereka membelot terhadap kami

jika lawan kita melakukan banyak pembelokan dalam belokan itu (2 atau lebih) kita hanya membelot ke arah mereka. jika itu hanya suara bising, suara itu akan mempengaruhi gerakan kita.

jika tidak, jika hanya 1 gerakan yang cacat, kami hanya melakukan tit sederhana untuk sisa permainan.

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]
Lemon dirusak
sumber
3

Bergantian

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'

Pilihan secara acak di babak pertama, lalu berganti. Selalu cacat dalam 10 putaran terakhir.

Chris
sumber
3

Tunggu 50

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

Setelah 50 cacat, biarkan mereka memilikinya!

MegaTom
sumber
Saya memperbaiki python Anda sambil mempertahankan niat Anda.
isaacg
Selamat telah pindah ke posisi ke-3.
isaacg
2

Entah mengapa naif

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'

Saya hanya akan berasumsi bahwa jika Anda membelot kurang dari probabilitas balik (kira-kira) di n terakhir bergantian, itu kebisingan dan tidak Anda sedang berarti!

Belum angka keluar yang terbaik n , mungkin melihat lebih jauh ke dalam.

JeroendeK
sumber
2

Setiap tiga

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"

Cacat setiap tiga putaran terlepas. Juga cacat 50 putaran terakhir. Juga cacat jika lawannya membelot 4 dari 5 putaran terakhir.

MegaTom
sumber
2

Ember

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'

Dimainkan dengan baik untuk memulai. Lihatlah 20 terakhir mereka, jika <25% d, mengembalikan c,> 75% d, mengembalikan d, dan di antaranya memilih secara acak di sepanjang fungsi probabilitas linier. 50 cacat terakhir. Punya ini pada 10 terakhir tetapi melihat banyak 50 cacat terakhir.

Pertama kali di sini jadi beri tahu saya jika ada sesuatu yang perlu diperbaiki (atau bagaimana saya bisa menguji ini).

brian_t
sumber
Jika Anda ingin menguji berbagai hal secara lokal, Anda dapat mengkloning repositori , dan menjalankan noisy-game.py. Butuh beberapa saat, jadi Anda mungkin ingin menghapus beberapa lawan playersuntuk iterasi cepat.
isaacg
Terima kasih Isaac - saya harus bermain dengannya dan bermain-main.
brian_t
1

Tit-For-Stat

Cacat jika lawan telah membelot lebih dari separuh waktu.

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