Bu mücadelede, gürültülü yinelenen mahkumun ikilemini oynayacaksınız.

Mahkumların açmazı işbirliği veya kusur: iki oyuncu, iki seçenekli her vardır oyun teorisinde bir senaryodur. Her oyuncu, işbirliği yapmama ihtimaline karşı kusurlu olursa, kendileri için daha iyisini yapar, ancak her iki oyuncu da, her iki oyuncunun da her iki oyuncunun da kusurlu olduğu birleştiği sonucu tercih eder.

Tekrarlanan mahkumun ikilemi, aynı rakibe karşı tekrar tekrar oynamanız ve rakibinizin geçmişte ne oynadığını bilmeniz dışında aynı oyundur. Hedefiniz, rakibinizin nasıl yaptığından bağımsız olarak daima kendiniz için en yüksek puanı toplamaktır.

Gürültülü yinelenen mahkumun ikilemi, iletişimin bir miktar gürültüsüne neden oluyor. Rakibinizin geçmişte neler oynadığına dair bilginiz biraz ortaya çıkacak. Geçmişte ne gibi hareketler yaptığınızı da bileceksiniz. Gürültü oranı, aynı rakibe karşı bir rauntta sabittir, ancak farklı raundlar arasında farklıdır.

Meydan okuma

Bu zorlu görevde, gürültülü yinelenen mahkumların ikilemini oynamak için bir Python 3 programı yazacaksınız.

Programınız üç girdi alacak:

• Kendi hamle, olmadan rastgele çevirir uyguladı.

• Rakibin hamleleri, rastgele atışlarla uygulanır.

• Her turda boş bir liste olarak başlayan ve isterseniz değiştirebileceğiniz bir durum değişkeni. Kullanmak istemiyorsanız, bunu görmezden gelebilirsiniz.

Programınız 'c'işbirliği yapmak veya 'd'hatalı olmak için çıktı vermelidir .

Örneğin, rakip geçmişte zamanın en az% 60'ını işbirliği yapıyorsa, rastgele izinler uygulandıktan sonra ve ilk 10 gösterim için işbirliği yapan bir program:

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'

Python'u bilmiyorsanız, gönderinizi sözde kodla yazın; biri (ben veya sitenin başka bir üyesi) ilgili Python programını yapabilir.

Oynanış

Turnuva koşucusu burada bulunabilir: gürültülü oyun . noisy-game.pyTurnuvayı çalıştırmak için koş. Bu havuzu yeni gönderilerle güncel tutacağım. Örnek programlar içinde bulunabilir basic.py.

Bir programın genel puanı, oyundaki 100 oyundan fazla olan puandır.

Bir oyun, kendisi de dahil olmak üzere her bir oyuncunun her oyuncunun karşı oynadığı robin eşleşmesinden oluşur. Bir eşleşme 100 turdan oluşur. Bir tur, her biri 'c'veya çıktısını içeren 300 hareketten oluşur 'd'.

Gönderiniz, kendi gönderiniz de dahil olmak üzere her gönderimle eşleşecek. Her maç 100 turdan oluşacak. Her turda, bir çevirme olasılığı rastgele bir şekilde rastgele seçilecektir [0, 0.5].

Her turda 300 hamle oluşacak. Her hamlede, her iki program da denedikleri önceki tüm oyunları ve diğer programın yaptığı önceki tüm oynatmaları, flipsler uygulandıktan sonra ve programın isterse değiştirebileceği değişken bir liste olan bir durum değişkeni alır. Programlar hamlelerini çıkaracak.

Hareketler aşağıdaki gibi puanlanır: Bir program a oynarsa 'c', rakip program 2 puan alır. Bir program a oynarsa 'd', o program 1 puan alır.

Daha sonra, her hareket bağımsız olarak çevirme olasılığına eşit olasılıkla çevrilir ve rakibe gösterilmek üzere saklanır.

Tüm turlar oynandıktan sonra, her oyuncunun her maçta aldığı puanları toplarız. Ardından, her oyuncunun oyundaki puanını hesaplamak için aşağıdaki puanlama sistemini kullanıyoruz. Bu puanlama, tüm eşleşmeler tamamlandıktan sonra gerçekleştirilir.

puanlama

Evrimsel puanlamayı kullanacağız. Her program eşit ağırlıkta başlar. Ardından, ağırlıklar 100 yineleme için oyundaki puan toplamları kullanılarak aşağıdaki gibi güncellenir:

Her programın yeni ağırlığı, önceki ağırlığının ürünü ve rakiplerinin ağırlıkları tarafından ağırlıklandırılan ortalama toplam puanı ile orantılıdır.

Bu tür 100 güncelleme uygulanmaktadır ve son ağırlıklar oyunun o koşusu için her programın puanıdır.

Genel puanlar, oyunun 100'den fazla koşusunun toplamı olacaktır.

Oyuncular bu zorluğun geçerli cevapları ve bizi başlatacak altı temel program olacak.

Uyarılar

Girişleri değiştirmeyin. İşbirliği veya kusurlama dışında başka bir programın yürütülmesini etkilemeye çalışmayın. Başka bir sunumu tanımaya çalışan ve bu rakibe kendi pahasına yarar sağlayacak bir fedakarlık sunumu yapmayın. Standart boşluklar yasaklandı.

EDIT: Gönderiler, temel programların hiçbirini veya daha önceki gönderileri tam olarak çoğaltamaz .

Herhangi bir sorunuz varsa, sormaya çekinmeyin.

Güncel sonuçlar

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

Sonuçlar bu soruya ve rakibin oyununu görmezden temel programlara sadece cevapları ile:

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

Kazanan

Yeni başvurular yayınlandıkça yarışma süresiz açık kalacak. Ancak, bu sorunun gönderilmesinden 1 ay sonra elde edilen sonuçlara dayanarak kazanan (bir cevap kabul) ilan edeceğim.

Genug ist nicht genug

(ayrıca çağrılabilir enough2veya 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"

İki başlığın orijinal başlığının, aynı gibi iki ardışık baş için beklediğini öğrendim ve aslında daha önce beklediğimiz başlıkları tit_for_whoopsaffetmemiz ve unutmamız gerektiği (aslında, neredeyse ...) görünüyor. Ve son turlarda pek çok oyuncu arızalı. Şimdiye kadar her şey yolundayken hala iyi olmayı tercih ediyorum, ancak botun tolerans çubuğu daha da aşağı inmeye devam ediyor.

Kısasa Whoops

Ncase.me/trust adresinden gelen bir stratejiden ilham aldı

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'

Yanlış anlaşılmaları önlemek için sadece diğer oyuncu arka arkaya iki kez hata yaptığında hata yapar.

Fikir değişimi

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

Ortada kalbin değişmesi var. Şaşırtıcı derecede iyi yapar.

Strateji Stealer

Yeterli, change_of_heart ve baştankara için baştankara esinlenerek. Biraz daha bağışlayıcı olmalı. En iyi sonuçları elde etmek için sayıları ayarlamaya çalıştım, ancak çok fazla değişiklik yapmak istemediler.

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"

Eğer çoğu zaman beni incitiyorsanız, size sadece zarar veririm. Muhtemelen.

Büyüyen Güvensizlik

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'

Rakip bana ne kadar ihanet ederse, o kadar az güvenirim sadece gürültü oldu.

Jedi2Sith

Tüm güzel ve özverili olmayanları başlatır, ancak zamanla karanlık tarafın etkisi, dönüşü olmayana kadar istikrarlı bir şekilde güçlenir. Bu etkiyi durduracak hiçbir şey yok, ama gördüğü tüm kötü şeyler karanlık tarafın gücüne katkıda bulunuyor ...

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'

Çevrimiçi deneyin!

kaydırıcı

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'

'C' ile başlar ve yavaş yavaş 'd' yönünde veya bu noktadan uzağa doğru kayar.

İnatçı 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'

Kötüye kullanım eşik stratejinizden yola çıkarak, yalnızca tutarlı oyunlarla kusur ve çoğunlukla işbirliği arasında geçiş için takipte bulundular

GÜNCELLEME: İki ardışık ve üç ardışık oyunun kaydını tutar, sadece daha zor şartlar altında ceza verir ve emin olmadığında rastgele bir seçim ekler

GÜNCELLEME 2: Kaldırılan koşul ve eklenen dağıtım işlevi

Gürültü Bot

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

Kesinlikle botla işbirliği yapıyorum. Bu sadece ses.

Yeter Yeterli

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"

İki tırnağın ardışık olmak zorunda olmadığı iki çizgi için baştankara olarak başlar (aksine tit_for_whoops). dÇok sık oynamak zorunda ise d-total gider .

Akvaryum balığı bot

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

Bir akvaryum balığı asla affetmez, ancak çabucak unutur.

hileci (tekrar eski durumuna getirildi)

Sadece son 10 oyun muhasebeleştirilir, ancak her biri iyi veya kötü olarak sınıflandırılan ortalamaların beşlik bloğuna bölünür.

Rakip ortalama "güzel" oynarsa, hileci daha az ve daha az iyi oynuyor. Eğer sonuçlar belirsiz ise, hileci rakibi emniyete almak için iyi oynar. Rakip "kötü" oynuyor görünüyorsa, hileci misilleme yapar.

Buradaki fikir şimdi ve daha sonra naif oyunculardan puanlar toplamak, aldatıcı olanları erken yakalamak.

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'

Feragatname: Daha önce buraya hiç göndermedim, yanlış bir şey yapıyorsam> lütfen söyle ve düzelteceğim.

Hafızanın Bozulması

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'

Son tarihi daha ağır. Yavaşça geçmişi unutuyor.

rüşvet

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"

Bazı belirsiz fikirler ...

Bütün "Gürültü" Şeyini Gerçekten Almaz

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

Bir haini asla affetmez.

siren:

düzenleme: muhtemelen düşük gürültü senaryolarında misilleme eklendi

Temel olarak, eğer ilk 4 hareketin hepsi işbirliği yapıyorsa, bu normalden daha az gürültü beklememiz gerektiği anlamına gelir. Asla kusurlu olmadığımız puanları telafi etmek için sık sık birazcık kusurluyuz ve gürültüden sorumlu tutulmasını sağlayın. ayrıca bize karşı kusur gösterirlerse misilleme yaparız

Rakibimiz bu sıralarda (2 veya daha fazla) çok fazla kusur yaparsa, onlara karşı hata yaparız. Sadece gürültü olsaydı, gürültü yine de hareketlerimizi etkilerdi.

Aksi takdirde, sadece 1 hamle hatalıysa, oyunun geri kalanı için basit bir baştankara yaparız.

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]

Alternatif

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'

İlk turda rastgele seçtikten sonra dönüşümlü olarak devam eder. Daima son 10 turdaki kusurları.

50 saniye bekle

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

50 hatadan sonra, hadi olsun!

Bir parça saf

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'

Sadece son daha az çevirme olasılığı (kabaca) daha hatalı verdiyseniz farz edeceğiz n dönüşler, bu gürültü ve o sen miydin olduğun anlamına!

En iyiyi çözemedim , buna daha fazla bakabilirim.

Her üç

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"

Her üç turdan bağımsız olarak arızalanır. Ayrıca son 50 dönüşü de bozuyor. Ayrıca rakibi son merminin 5'inden 4'üne müsaade ettiğinde de hata yapar.

Kovalar

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'

Başlamak için güzel oynuyor. <% 25 d, c,>% 75 d, d döndürür ve aralarında doğrusal bir olasılık işlevi boyunca rastgele seçimler varsa, son 20'lerine bakar. Son 50, kusurlar. Bunu son 10'da geçirdim ama son 50 hatada çok gördüm.

Buraya ilk kez bir şeyin düzeltilmesi gerekip gerekmediğini bana bildirin (veya bunu nasıl test edebilirim).

Kısasa Stat

Rakip zamanın yarısından fazlasını saptarsa ​​hatalar.

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