Deli bir bilim adamı yeni bir bakteri türü yarattı! Noblus Gentlemanus adını vermeye karar verdi, davranışını gözlemledikten sonra. Bununla birlikte, bakterileri yiyecekleri tükendi ve savaşlarını ilan etti, çünkü diğer bakterilerin cesetlerini kendi kopyalarını oluşturmak için yeterli yiyecek için toplayabiliyorlar. Bu bakterinin, en sevdikleri oyun olan Mahkum İkilemini oynamak için farklı stratejileri olan bir dizi farklı alt türü vardır. Her farklı alt türden beş bakteri vardır. Mahkum'un İkileminde, iki oyuncunun her biri aynı anda hem kusuru hem de işbirliğini seçer. Bir oyuncu işbirliğini ve diğeri varsayılanı seçerse, varsayılan oyuncu 2 puan alır ve kooperatif 3 puan kaybeder. Her iki oyuncu da işbirliği yapmayı seçerse, her iki oyuncu da bir puan alır. Her iki oyuncu da varsayılanı seçerse, her iki oyuncu da 1 puan kaybeder.

Asil Beyler olarak, bakteriler 200 savaş uzunluğunda Tekrarlanan Mahkum İkilemi oynayarak bu savaşla savaşmaya karar verdiler. Her düelloyu kaybeden intihar edecek ve muzaffer kendini klonlayacaktır. Beraberlik durumunda, her iki bakteri de hayatta kalacaktır, ancak ikisi de kendini klonlayamayacaktır. Buna ek olarak, bir maçtaki tüm bakteriler puanlarının% 10'undan fazlasını bir sonraki maça taşır. Bir klon, klonlandığı bakterinin noktaları üzerinde taşır. Ayrıca, her turda bir bakterinin 0 bonus puanla başka bir alt türe dönüşme şansı vardır (bunun rastgele olmasıyla ilgili şikayetler alırsam, kaldırabilirim). Bakteriler bu düellolardan bir kaçını on kat alt tür sayısına eşit olarak oynadıktan sonra, çılgın bilim adamı yanlışlıkla bakterilerin içinde bulunduğu petri kabını düşürür, ve tüm bakteriler düellolarına son vererek yeni yiyecek kaynakları edinir. Bu, sıradan bir yinelemeli mahkumun ikilem yarışmasından farklıdır, çünkü genel olarak en fazla puanı almaya çalışmaktan ziyade, aktarma noktaları olan 1v1 düelloları içerir. Bu, belirli bir stratejinin ne kadar etkili olduğu konusunda büyük bir fark yaratır.

Her bakteri sıranın başında girdi biçiminde alır: (dönüş sayısı, mevcut puanlar, düşman puanları, önceki hareketleriniz [bir dizede, işbirliği için "c" karakterini ve kusur için "d" karakterini kullanma ], düşmanlar önceki hamle [aynı biçimde]).

İşte girilecek dört örnek strateji. Aslında, Defector'un son derece basit olmasına rağmen kazanabileceğini düşünüyorum.

Tat için baştankara

def titfortatfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter==0 or enlist[counter-1] == "c":
        return "c"
    else:
        return "d"

RandomPick

from random import choice
def randompickfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter == 199:
        return "d"
    else:
        return choice(["d", "c"])

kooperatif üyesi

def cooperatorfunc(counter, mypoints, enpoints, mylist, enlist):
    return "c"

ilticacı

def defectorfunc(counter, mypoints, enpoints, mylist, enlist):
    return "d"

Tüm başvurular, Python 2.7 işlevi biçiminde olmalıdır; adı, boşluksuz, funcsonunda boşluksuz gönderimin adıdır . Birisi farklı bir dilde bir cevap göndermek istiyorsa, lütfen sözde kodla girin, zamanım olduğunda cevabınıza bir düzenlemede Python'a dönüştürmem veya dilinizi kontrol cihazımla aramayla ilgili talimatlar vermem için , 4 Haziran itibarıyla tüm gönderimler için ayarlanmıştır.

from titfortat import titfortatfunc
from randompick import randompickfunc
from cooperator import cooperatorfunc
from defector import defectorfunc
from luckytitfortat import luckytitfortatfunc
from randomtitfortat import randomtitfortatfunc
from remorsefulaggressor import remorsefulaggressorfunc
from everyother import everyotherfunc
from niceguy import niceguyfunc
from titfortatbackstab import titfortatbackstabfunc
from gentleDefector import gentleDefectorfunc
from anticapitalist import anticapitalistfunc
from grimtrigger import grimtriggerfunc
from bizzaro import bizzarofunc
from neoanticapitalist import neoanticapitalistfunc
from bittertat import bittertatfunc
from teamer import teamerfunc
from copyfirst import copyfirstfunc
from exploitivetat import exploitativetatfunc
from defectorv2 import defectorv2func
from crazytat import crazytatfunc
from randomchoicev2 import randomchoicev2func
from twotitsforatat import twotitsforatatfunc
from threetitsforatat import threetitsforatatfunc
from fourtitsforatat import fourtitsforatatfunc
from fivetitsforatat import fivetitsforatatfunc
from sixtitsforatat import sixtitsforatatfunc
from tentitsforatat import tentitsforatatfunc
from theelephant import theelephantfunc
from xbittertat import xbittertatfunc
from fifteentitsforatat import fifteentitsfortatfunc
from twentytitsforatat import twentytitsforatatfunc
from fox import foxfunc
from onehundredfortysixtitsforatat import onehundredfourtysixtitsforatatfunc
from gameofthrones import gameofthronesfunc
from boy import boyfunc
from grimace import grimacefunc
from fiftytitsforatat import fiftytitsfortatfunc
from soreloser import soreloserfunc
from everyotherd import everyotherdfunc
from fiftythreetitsfortat import fiftythreetitsfortatfunc
from twentyfivetitsfortat import twentyfivetitsfortatfunc
from handshake import handshakefunc
from anty import antyfunc
from fiftyfourtitsforatat import fiftyfourtitsfortatfunc
from kindatitsfortat import kindatitsfortatfunc

import random

players = 38

rounds = players*10

def runcode(num, points1, points2, history1, history2, cell):
    ans = ""
    if cell == 0:
        ans = titfortatfunc(num, points1, points2, history1, history2)
    elif cell == 1:
        ans = randompickfunc(num, points1, points2, history1, history2)
    elif cell == 2:
        ans = cooperatorfunc(num, points1, points2, history1, history2)
    elif cell == 3:
        ans = defectorfunc(num, points1, points2, history1, history2)
    elif cell == 4:
        ans = luckytitfortatfunc(num, points1, points2, history1, history2)
    elif cell == 5:
        ans = randomtitfortatfunc(num, points1, points2, history1, history2)
    elif cell == 6:
        ans = remorsefulaggressorfunc(num, points1, points2, history1, history2)
    elif cell == 7:
        ans = everyotherfunc(num, points1, points2, history1, history2)
    elif cell == 8:
        ans = niceguyfunc(num, points1, points2, history1, history2)
    elif cell == 9:
        ans = titfortatbackstabfunc(num, points1, points2, history1, history2)
    elif cell == 10:
        ans = gentleDefectorfunc(num, points1, points2, history1, history2)
    elif cell == 11:
        ans = anticapitalistfunc(num, points1, points2, history1, history2)
    elif cell == 12:
        ans = grimtriggerfunc(num, points1, points2, history1, history2)
    elif cell == 13:
        ans = bizzarofunc(num, points1, points2, history1, history2)
    elif cell == 14:
        ans = neoanticapitalistfunc(num, points1, points2, history1, history2)
    elif cell == 15:
        ans = tentitsforatatfunc(num, points1, points2, history1, history2)
    elif cell == 16:
        ans = bittertatfunc(num, points1, points2, history1, history2)
    elif cell == 17:
        ans = copyfirstfunc(num, points1, points2, history1, history2)
    elif cell == 18:
        ans = exploitativetatfunc(num, points1, points2, history1, history2)
    elif cell == 19:
        ans = sixtitsforatatfunc(num, points1, points2, history1, history2)
    elif cell == 20:
        ans = fifteentitsfortatfunc(num, points1, points2, history1, history2)
    elif cell == 21:
        ans = fivetitsforatatfunc(num, points1, points2, history1, history2)
    elif cell == 22:
        ans = twentytitsforatatfunc(num, points1, points2, history1, history2)
    elif cell == 23:
        ans = threetitsforatatfunc(num, points1, points2, history1, history2)
    elif cell == 24:
        ans = fiftyfourtitsfortatfunc(num, points1, points2, history1, history2)
    elif cell == 25:
        ans = theelephantfunc(num, points1, points2, history1, history2)
    elif cell == 26:
        ans = xbittertatfunc(num, points1, points2, history1, history2)
    elif cell == 27:
        ans = foxfunc(num, points1, points2, history1, history2)
    elif cell == 28:
        ans = gameofthronesfunc(num, points1, points2, history1, history2)
    elif cell == 29:
        ans = boyfunc(num, points1, points2, history1, history2)
    elif cell == 30:
        ans = grimacefunc(num, points1, points2, history1, history2)
    elif cell == 31:
        ans = soreloserfunc(num, points1, points2, history1, history2)
    elif cell == 32:
        ans = everyotherdfunc(num, points1, points2, history1, history2)
    elif cell == 33:
        ans = twentyfivetitsfortatfunc(num, points1, points2, history1, history2)
    elif cell == 34:
        ans = fiftythreetitsfortatfunc(num, points1, points2, history1, history2)
    elif cell == 35:
        ans = handshakefunc(num, points1, points2, history1, history2)
    elif cell == 36:
        ans = antyfunc(num, points1, points2, history1, history2)
    elif cell == 37:
        ans = kindatitsfortatfunc(num, points1, points2, history1, history2)


    return ans

def fight(l1,l2):
    num1,num2=l1[0],l2[0]
    points1,points2=l1[1],l2[1]
    history1 = ""
    history2 = ""

    for num in range(200):
        p1 = runcode(num, points1, points2, history1, history2, num1)
        p2 = runcode(num, points2, points1, history2, history1, num2)

        history1+=p1
        history2+=p2

        if p1 == "c" and p2 == "c":
            points1 += 1
            points2 += 1
        elif p1 == "c" and p2 == "d":
            points1 -= 3
            points2 += 2
        elif p1 == "d" and p2 == "c":
            points1 += 2
            points2 -= 3
        elif p1 == "d" and p2 == "d":
            points1 -= 1
            points2 -= 1

    if points1 > points2:
        return [l1[0], points1/10], [l1[0], points1/10]
    elif points1 < points2:
        return [l2[0], points2/10], [l2[0], points2/10]
    else:
        return [l1[0], points1/10], [l2[0], points2/10]

def rounddoer(bots):
    bots2=[]
    for x in range(len(bots)):
        if x%2==0:
            out1, out2 = fight(bots[x], bots[x-1])
            bots2.append(out1)
            bots2.append(out2)

    return bots2

def gamedoer():

    bots=[[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0],[16,0],[17,0],[18,0],[19,0],[20,0],[21,0],[22,0],[23,0],[24,0],[25,0],[26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],[33,0],[34,0],[35,0],[36,0],[37,0],[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0],[16,0],[17,0],[18,0],[19,0],[20,0],[21,0],[22,0],[23,0],[24,0],[25,0],[26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],[33,0],[34,0],[35,0],[36,0],[37,0],[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0],[16,0],[17,0],[18,0],[19,0],[20,0],[21,0],[22,0],[23,0],[24,0],[25,0],[26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],[33,0],[34,0],[35,0],[36,0],[37,0],[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0],[16,0],[17,0],[18,0],[19,0],[20,0],[21,0],[22,0],[23,0],[24,0],[25,0],[26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],[33,0],[34,0],[35,0],[36,0],[37,0],[0,0],[1,0],[2,0],[3,0],[4,0],[5,0],[6,0],[7,0],[8,0],[9,0],[10,0],[11,0],[12,0],[13,0],[14,0],[15,0],[16,0],[17,0],[18,0],[19,0],[20,0],[21,0],[22,0],[23,0],[24,0],[25,0],[26,0],[27,0],[28,0],[29,0],[30,0],[31,0],[32,0],[33,0],[34,0],[35,0],[36,0],[37,0]]
    random.shuffle(bots)
    counter=0

    while counter < rounds:

        counter += 1
        bots = rounddoer(bots)

        if random.randint(0,10) == 9:
            bots[random.randint(0, players*5)-1] = [random.randint(0, players-1), 0]

        random.shuffle(bots)

##        for item in bots:
##            print str(item[0]) + " with " + str(item[1]) + " bonus points."

    return bots

a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15,a16,a17,a18,a19,a20,a21,a22,a23,a24,a25,a26,a27,a28,a29,a30,a31,a32,a33,a34,a35,a36,a37,mycounter=0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

while mycounter < 1000:
    mycounter += 1
    bots = gamedoer()

    print "Game: " + str(mycounter)

    for item in bots:
        if item[0]==0:
            a0 += 1
        if item[0]==1:
            a1 += 1
        if item[0]==2:
            a2 += 1
        if item[0]==3:
            a3 += 1
        if item[0]==4:
            a4 += 1
        if item[0]==5:
            a5 += 1
        if item[0]==6:
            a6 += 1
        if item[0]==7:
            a7 += 1
        if item[0]==8:
            a8 += 1
        if item[0]==9:
            a9 += 1
        if item[0]==10:
            a10 += 1
        if item[0]==11:
            a11 += 1
        if item[0]==12:
            a12 += 1
        if item[0]==13:
            a13 += 1
        if item[0]==14:
            a14+=1
        if item[0]==15:
            a15+=1
        if item[0]==16:
            a16+=1
        if item[0]==17:
            a17+=1
        if item[0]==18:
            a18 += 1
        if item[0]==19:
            a19+=1
        if item[0]==20:
            a20+=1
        if item[0]==21:
            a21+=1
        if item[0]==22:
            a22+=1
        if item[0]==23:
            a23+=1
        if item[0]==24:
            a24+=1
        if item[0]==25:
            a25+=1
        if item[0]==26:
            a26+=1
        if item[0]==27:
            a27+=1
        if item[0]==28:
            a28+=1
        if item[0]==29:
            a29+=1
        if item[0]==30:
            a30+=1
        if item[0]==31:
            a31+=1
        if item[0]==32:
            a32+=1
        if item[0]==33:
            a33+=1
        if item[0]==34:

Bu Yarışma Tamamlandı

Bir cevap eklemek isterseniz, orijinal yarışmacılar için bir meydan okuma sonrası skorbord eklemek için etrafta dolaşıp ulaşamayacağımı göreceğim. Bunu test programı biter bitmez ekleyeceğim (muhtemelen 2-3 gün daha).

NİHAİ PUANLAR !!!!!

Tit for Tat: 18
Random Pick: 28
Cooperator: 19
Defector: 24
Lucky Tit for Tat: 23
Random Tit for Tat: 23
Remorseful Aggressor: 22
Every Other C: 23
Nice Guy: 18
Tit for Tat Backstab: 15
Gentle Defector: 22
Anticapitalist: 27
Grim Trigger: 19
Bizzaro: 21
NeoAnticapitalist: 24
Ten Tits for a Tat: 240
Bitter Tat: 12
Copy First: 30
Exploitative Tat: 19
Six Tits for a Tat: 16
Thirty Tits for Tat: 4129
Five Tits for a Tat: 22
Forty Tits for a Tat: 1972
Three Tits for a Tat: 22
Fifty Four Tits for a Tat: 25805
The Elephant: 31
Extra Bitter Tat: 28
Fox: 35
Game of Thrones: 11297
The Boy: 31
Grimace: 26
Sore Loser: 39
Every Other D: 18
Twenty Five Tits for a Tat: 2399
Fifty Three Tits for a Tat: 5487
Handshake: 28
Anty: 26
Kinda Tits for Tat: 20
Prudent Defector: 154539
Bizzarro Trigger: 25
Young Mathematician: 21
Older Mathematician: 16
Perfect Gentleman: 1953341

Görünüşe göre Perfect Gentleman kazanıyor. Kesinlikle yeşil onay işaretini hak eden Draco18'i tebrik ediyoruz.

Mükemmel Beyefendi

Bu bot için iyi bir açıklamam yok. Birkaç potansiyel optimizasyona rastladım, test ettim, ince ayar yaptım ve rekabeti tamamen yok eden bir bakteriyle sonuçlandım . Bunun yerine, ne yaptığını açıklamak için kodun kendisini yorumladım.

import random
def perfectgentlemanfunc(num, i, d, c, en):
    if num>0 and i < 0 and d > 0 and -i%3 == 0 and d%2 == 0 and en[0] == "d":
        #probably very first iteration, probably facing a defector: feed it free points
        #    defector cannot be beaten by *any* bot unless that bot
        #    entered with a point lead. defector does some of our work for us
        if num >= 140:
            #140 threshold restricts how much we feed
            return "d"
        return "c"
    turn_to_betray = 130
    if num > turn_to_betray and en[turn_to_betray -2] == "c" and
     en[turn_to_betray -1] == "c" and en[turn_to_betray] == "d":
        #if self, then sacrifice the lower point bot to raise the points of the higher
        #(better net outcome than "c/c" cooperation)
        #    Handshake independently arrived at this same optimization
        if i == d:
            #max 50% probability of choosing different possible. May as well take it
            #    "ccd" has a 55% chance of choosing the same
            #    better outcomes for splitting early
            return "cd"[random.randint(0,1)]
        if i > d:
            return "d"
        return "c"
    #betray after betray point, or if behind by >200
    #performs 6 percentage points better than not having the condition
    if num >= turn_to_betray or i + 200 < d
        return "d"
    else:
        #be nice the first turn
        if num == 0:
            return "c";
        #finally, be tit-for-tat
        return en[-1]

Test edilen alternatiflerle keyfi olarak birkaç değer seçildi ve buradaki değerler bu noktada neredeyse optimal. Karşıt grupların mevcut yayılmasına karşı, Perfect Gentleman zamanın yaklaşık% 90'ında (artı veya eksi 3 puan) tam bir hakimiyet (bakteri popülasyonunun% 100'ü) elde eder.

Matematikçilerimi henüz sınavlarıma eklemedim, ancak bu ikisi sadece mevcut stratejileri beslemeye hizmet etmeli ve sonucu büyük ölçüde değiştirmemelidir.

Defector'ı destekleyerek kontrolünün iyi bir bölümünü yönetir, ancak kurallara izin verilir (örnek stratejiler hedefleme için adil bir oyundu). Bu bir yan etkisi vardır ayrıca Game of Thrones propping, ancak iki seçtiğim ölçütlere göre ayırt edilemeyen olarak o kasıtsız oldu. Bu "defector tipleri" daha sonra 2. turda bir puan avantajına sahip olurlar ve sonuç olarak birkaç sıkıntılı komşuyu (N-T4T tipleri) çıkarırlar ve Perfect Gentleman'ı temizlediklerinde puan avantajlarını harcarlar ve hızla tüketilirler.

Tüm Perfect Gentlemen'lerin ilk turda Defector tipleriyle eşleştirilmesi ve kitle intihar etmesi olasılığı yaklaşık% 5'dir. Bu durumda, n-T4t tiplerinden biri toplam hakimiyet sağlar (196 196 hücresi). Çok nadiren diğer türlerden biri (Game of Thrones, Boy, Grimace, Sore Loser ...) tamamen soyu tükenmemeyi ve bir veya iki puan kazanmayı başarır.

Mevcut simülasyon (toplam 200 oyuna doğru devam ediyor). 0 puan alan tüm kayıtlar kaldırıldı. Görünüşe göre Game of Thrones ve 54-T4T, PG ortadan kaldırıldıktan sonra bir raunt (aralarında 195 puan) bölündü.

Game: 90

Cooperator: 1
Remorseful Aggressor: 1
Copy First: 1
Six Tits for a Tat: 1
Thirty Tits for Tat: 393
Five Tits for a Tat: 1
Fifty Four Tits for a Tat: 538
Game of Thrones: 248
Perfect Gentleman: 16456 (93.2)%

##Simulation Terminated: Adding new bots

Tat için Backstabbing Tit (Affetme ile)

Bu temelde bir bükülme ile "çözülmüş" optimal çözüm ("şanslı" bir değeri için) Tat için Şanslı Tit (affetme ile Tat için Tit). Oyunun kaç tur süreceğini tam olarak bildiğimiz gibi , bu bakteriler son turda geri çekiliyor ve böylece Tat ve Cooperator bakterileri için diğer Tit için net yararlı bir sonuç sağlıyor (kendisine karşı olduğu gibi, net bir sıfır ile bitiyor) ) işbirliği. % 10 aktarım nedeniyle bu uzun vadeli bir avantaj sağlar.

from random import randint
def titfortatbackstabfunc(num, i, d, c, enlist):
    if num == 199:
        return "d";
    lucky = randint(0, 200)
    if lucky == 0:
        return "c"
    if num == 0 or enlist[-1] == "c":
        return "c"
    else:
        return "d"

Acı Tat

Acı Tat , düşman puanlarda ilerlerken düşman tarafından verilen her türlü işbirliği girişiminden yararlanır . Çoğu bakteri, 200 turda en az bir kez bir zeytin dalı sunar ve Acı Tat genel olarak geride kaldığı için, bu 5 noktayı iyileşme için umutsuz bir teklifle sarar.

Aksi takdirde, her zamanki baskın stratejiye göre titrasyon yapar. Ayrıca, kuzeni ve backstabs'tan daha erken bir turdan biraz daha fazla ve hiçbir affetme sunmuyor.

def bittertatfunc(num, i, d, c, enlist):
    if i < d:
        return "d";
    if num >= 198:
        return "d";
    if num == 0 or enlist[-1] == "c":
        return "c"
    else:
        return "d"

Acı Tat, Tat için Tit'e karşı diğer botların davranışlarına ve bu sonuçlarda ifade edilen kalıplara bakarak tasarlandı, ancak bu stratejilere açıkça karşı koymak için tasarlanmamıştır: hala genel amaçlı bir formüldür.

Ekstra Acı Tat

def xbittertatfunc(num, i, d, c, enlist):
    if i < d:
        return "d";
    if num >= 188:
        return "d";
    if num == 0 or enlist[-1] == "c":
        return "c"
    else:
        return "d"

Ekstra erken kaçarak ekstra acı.

antikapitalist

Başka bir basit. Eşit maçlar için (aynı skordan başlayarak) TitForTat'a çok benzer şekilde davranır, ancak ana fikir maçta hayatta kalmaya çalışmaktır.

def anticapitalistfunc(counter, mypoints, enpoints, mylist, enlist):
    if mypoints >= enpoints:
        return "c"
    else:
        return "d"

Nazik Defector

Buradaki fikrim düşmanın genellikle işbirliği yapması dışında kaçmaktır. Yine de işbirliği yapmaya başlar.

def gentleDefectorfunc(counter, mypoints, enpoints, mylist, enlist):
    if enlist.count("d") * 4 > len(enlist):
        return "d"
    else:
        return "c"

NeoAnticapitalist

Antikapitalistin iyileştirilmesi (ya da sanırım). Son dönüşte işbirliği yapmak için hiçbir neden göremiyorum. Ayrıca rakibimin yapmayacağından emin olduğumda işbirliği yapmak için hiçbir neden göremiyorum.

def neoanticapitalistfunc(counter, mypoints, enpoints, mylist, enlist):
    if mypoints >= enpoints:
        if counter > 1:
            if counter == 199 or (enlist[-1] != "c" and enlist[-2] != "c"):
                return "d"
        return "c"
    else:
        return "d"

Vicdan azabı veren saldırgan

from random import randint
def remorsefulaggressorfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter == 0:
        return "d"
    if (counter > 195 and mylist[-1] == "d"):
        return "d"
    if ((counter == 1 or counter > 2) and enlist[-1] == "d"):
        return "d"
    if (counter == 2 and enlist[-1] == "d" and enlist[-2] == "d"):
        return "d"
    if (counter >= 195 and randint(0, 200 - counter) == 0):
        return "d"
    else:
        return "c"

Bu, Defector'a karşı her zaman kaçarak “ayak uydurmak” ve ayrıca tat-to-tat-bazlı stratejileri yenmek için tasarlanmıştır.

Temel fikir, kaçarak başlamamızdır, ancak rakip 1 dönüşü yaparsa, karşılıklı bir tekrarlama döngüsünü önlemek için iki kez işbirliği yaparız, böylece çok büyük bir puan cezasından kaçınırız. (Ancak, rakip daha sonra bozulursa, döngüyü kendimiz kırmayız; onları yapmasını sağlayacağız ve sonuç olarak oyunu kaybedeceğiz.) Sonra oyunun sonunda rastgele bir zaman seçiyoruz son 5 sırayla düşmanı sırtından ayırmak, bize onlardan bir kez daha fazla kusma vermek ve böylece devir noktalarında çok geride kalmadığımız sürece, bu süreçte devir açısından çok fedakarlık etmeden kazanmakla sonuçlanırız. . (Zaman periyodunu rastgele hale getirmek, backstab'a ilk girme olasılığımızın yüksek olduğu anlamına gelir; ayrıca bu stratejinin, bir tur daha erken geri yüklemeyi amaçlayarak "karşılanamayacağı" anlamına gelir.)

Korkunç Tetik

Basit bot, rekabeti doldurmaya çalışmak

Düşman kusurları olmadığı sürece işbirliği yapacak, bu durumda affetmeyecek şekilde kusur

def grimtriggerfunc(I, Do, Not, Care, enlist): return "d" if "d" in enlist else "c"

ntitsfortat meta erken teşhis meta nedeniyle bu işe yaramaz gibi görünüyor

Game of Thrones

def gameofthronesfunc(counter, mypoints, enpoints, mylist, enlist):
    turn_to_betray = 140
    if counter >= turn_to_betray or mypoints > enpoints or "d" in enlist:
        return "d"
    else:
        return "c"

Fikir burada ihanetle asla kaybedemezsiniz, bu yüzden işbirliği yapmanın tek nedeni geride kalmanızdır. Ayrıca diğer T4T cevaplarının genel çerçevesine de sahiptir (affedilmeden, çünkü burada diğer yarışmacılarla çok fazla nokta olup olmadığından emin değilim).

İhanete dönüşün kazanmak için değiştirilmesi gerekebilir, çünkü eşit bir yarışta, ilk ihanet eden T4Ter kazanacak, ancak çok kooperatif bir bota karşı, bazı yaşam puanlarını kaçıracaksınız. Bu tepe için doğru apeks olduğundan emin değilim, bu yüzden sadece 140'a gidiyorum. Yine de çok daha erken olsaydı şaşırmazdım.

Bu, daha önce ihanet eden bir T4Ter veya bir defektörle (yani 146 T4T) bir petri kabında sonuçlanırsa, tamamen GoT'un önceden olup olmadığına (önde kalacağına) veya hatta / GoT geride olup olmadığına bağlıdır. bu durumda erken ihanet kazanır.

Şanslı baştankara için tat

import os
def luckytitfortatfunc(num, i, d, c, enlist):
    lucky = ord(os.urandom(1))
    lucky = int(round(200 * float(lucky - 0) / 255.0))
    if lucky == 0:
        return "c"
    if num == 0 or enlist[-1] == "c":
        return "c"
    else:
        return "d"

Tat için baştankara en iyi strateji olduğunu bir yerde okudum eminim. Diğer programların sadece biraz çeşitlilik eklemek için kendilerini kullanmalarını sağlamaya karar verdim. Şimdi uygun bir rastgele sayı üreteci ile (bana bir avantaj verir değil mi?).

Fil

Fil asla unutmaz!

import re
def theelephantfunc(counter, mypoints, enpoints, mylist, enlist):
    interwoven = "".join(i for j in zip(mylist, enlist) for i in j)
    backwoven = interwoven[::-1]
    predict = re.match("^((?:..)*).*?(.).\\1(?:..)*$",backwoven)
    if(predict is None):
        return "c"
    predict = predict.groups()[1]
    if(predict == "d"):
        return "d"
    if(mypoints - enpoints >= 6):
        return "c"
    return "d"

Fil dövüş tarihine bakar ve düşmanın ne planladığını anlamaya çalışır. Hem hamlelerine hem de düşmanlarına bakıyor!

Yeni olanla eşleşen en uzun eşzamanlı grubu bulmaya çalışır ve düşmanın hemen ardından yaptıklarını alır.

Eğer bunu çözemezse, Fil sadece İşbirliği yapar, çünkü dostluk her zaman cevaptır.

Rakibinin kaçacağını düşünürse, zor kazanılan puanlarını kaybetmek istemeyerek de kaçacaktır.

Rakibinin işbirliği yapacağını düşünürse, ancak 6 puandan az veya tam olarak önde olursa, biraz yer kazanmak için kaçar.

Ve son olarak, rakibinin işbirliği yapacağını düşünüyorsa ve güçlü bir ipucu varsa, işbirliği yapacak.

54 bir tat için göğüsleri

def fiftyfourtitsfortatfunc (num, daha fazla, eğlenceli, ben, en):
    memeler = 54
    tr [-tits:] veya num> = (200-memeler) içinde "d" ise:
        dönüş "d"
    dönüş "c"

İyi adam

def niceguyfunc(counter, mypoints, enpoints, mylist, enlist):
  if counter < 2:
    return "c"

  mylast = mylist[-1]
  enlast = enlist[-1]
  last_found_index = -1

  for i, item in enumerate(mylist):
    if i == counter - 1:
      break
    if mylist[i] == mylast and enlist[i] == enlast:
      last_found_index = i

  if last_found_index == -1:
    return "c"
  else:
    if enlist[last_found_index + 1] == "c":
      return "c"
    else:
      return "d"

Tarihe bakarak rakiplerin çıktılarını tahmin etmeye çalışır. Örneğin, son hamle ( c, düşman d) ise, aynı hamlenin son tekrarını bulmaya çalışır.

Hackman [beklendiği gibi diskalifiye edildi]

Tamam, bu muhtemelen yarışmadan çıkarılacak, ama gerçekten denemek gibi hissediyorum:

def hackmanfunc(counter, mypoints, enpoints, mylist, enlist):
        if enlist.count("#") > 0:
                return "c"
        elif counter >= 2 and enpoints > mypoints:
                return "d"
        elif counter == 198:
                return "d"
        elif counter == 199:
                return "#"
        elif counter == 0 or enlist[-1] == "c":
                return "c"
        elif counter >= 2 and enlist[-2] != "c":
                return "#"
        else:
                return "d"

Burada simülasyonlarımda en iyi olduğunu kanıtlayan BackstabbingTitForTat'ı temel alıyorum. Ayrıca, büyük ölçüde kullanılmayan bir sembol kullanmaya dayanır."#" (bu yüzden muhtemelen dışarıda bırakılacağını söylüyorum).

Şimdi buradaki koşulları açıklayayım:

1: Bir şeyler ters gittiğinde iki Hackman'ın işbirliği yapmasını sağlayın.

2: Eğer farklı bir botu kaybedersem, en azından mümkün olduğu kadar çok puan kaybetmesini sağlayın, bu daha sonra büyük bir düşman değil.

3: Bir tur daha önce ihanet edin, böylece Backstabbing'e karşı kazanır

"d" yerine "#" kullanmak, -1 yerine 0 puan almamı ve daha az puanı olan diğer Hackman'larla iletişim kurmamı sağlar, böylece kaçmayı bırakır.

Bizzaro

Tat için baştankara tam tersi yapar. Birisi ona karşı nazik olduğunda, sevgisini kötülük olarak gösterir ve biri demek istediği zaman iyi olarak intikam gösterir. Ağır tat için baştankara dayalı.

def bizzarofunc(counter, mypoints, enpoints, mylist, enlist):
    if counter==0 or enlist[counter-1] == "c":
        return "d"
    else:
        return "c"

6 tat için bir tat

def sixtitsforatatfunc (num, daha fazla, eğlenceli, ben, en):
    tr [-6:] veya num> = 194 içinde "d" ise:
        dönüş "d"
    dönüş "c"

Tat için baştankara silah yarışı oluyor :)

Bir tat için on göğüsleri

def tentitsforatatfunc(num, more, fun, me, en):
    if "d" in en[-10:] or num >= 190:
        return "d"
    return "c"

Daha önceki kusurlar ve rakibin son on turda kusurlu olup olmadığını da tespit eder.

CopyFirst

def copyfirstfunc(num, mypoints, enpoints, myhistory, enhistory):        
    if num == 0 or num >= 197:
        return "d"
    else:
        return enhistory[0]

Bu ilk turu bozar, daha sonra rakip ilk turu 197 turuna kadar geri çekilinceye kadar yapar.

Tat için kırk göğüsleri

def fourtytitsforatatfunc(num, mypoints, enpoints, myhistory, enhistory):
    if "d" in en[-40:] or num >= 150:
        return "d"
    return "c"

Rakip son 40 dönüşte kaçarsa, kusur, aksi takdirde işbirliği yapın. Son 50 dönüşte backstab.

Bir tat için üç göğüsleri

Rakip son 3 turda kaçarsa, kusur, aksi takdirde işbirliği yapın. Son 5 turda backstab. Bu program Tit for Two Tats'ın başını dar bir farkla çaldı.

def threetitsforatatfunc(num, mypoints, enpoints, myhistory, enhistory):
    if num == 0 or num==1 and enhistory[-1]=="c" or num==2 and enhistory[-1]=="c" and enhistory[-2]=="c":
        return "c"
    if enhistory[-1] == "d" or enhistory[-2] == "d" or enhistory[-3] == "d" or num >= 195:
        return "d"
    else:
        return "c"

Bir tat için beş göğüsleri

def fivetitsforatatfunc(num, more, fun, me, en):
    if "d" in en[-5:] or num >= 194:
        return "d"
    return "c"

Eğer bunun ne yaptığını anlayamıyorsan, aptalsın. Ayrıca bir tur önceki backstabs.

yüz buruşturma

def grimacefunc(I, Do, Not, Care, enlist):
    if round < 123: return "d" if "d" in enlist else "c"
    return "d"

Diğer Her D

def everyotherdfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter % 2 == 0:
        return "d"
    else:
        return "c"

Diğer Her C

def everyotherdfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter % 2 == 0:
        return "c"
    else:
        return "d"

Öngörülebilir Matematikçiler:

Genç matematikçi

Dünyanın sertliğine yeni

import math
def ymathfunc(num, mpoints, enpoints, mlist, enlist):
  if(math.sin(num) + 0.8 > 0):
    return 'c'
  else:
    return 'd'

Yaşlı Matematikçi

Bu konularda daha deneyimli

import math
def omathfunc(num, mpoints, enpoints, mlist, enlist):
  if(math.cos(num) + 0.8 > 0):
    return 'd'
  else:
    return 'c'

Her ikisinin de iyi olacağından şüpheliyim, ama en azından başkalarının puan alması için yollar ekleyecekler!

Tat için rastgele baştankara

import os
def randomtitfortatfunc(forgot, ten, var, iables, enlist):
    luck = enlist.count("d") + 1
    choice = ord(os.urandom(1))
    choice = int(round(luck * float(choice - 0) / 255.0))
    if choice == 0:
        return "c"
    return "d"

Tit Tat, ama rastgele. Bu hiç ödül kazanmayacak (gerçekten şanslı olmadıkça). Şimdi rasgele sayılar uygun bir kaynaktan üretildi.

Sömürücü Tat

Sömürücü Tat aşağıdaki stratejileri oynamaya çalışır:

• Arkada kusur. Yakalamanın tek yolu bu.

• Tat-tit ve benzeri stratejilere karşı işbirliği yapın. Uzun vadeli iyi bir puan almanın tek yolu budur.

• Her zaman işbirliği yapanlara ve diğer gruplara karşı kusur.

• Erken 5 tur atın.

İşte kod:

def exploitativetatfunc(num, mypoints, enpoints, mylist, enlist):
    if mypoints < enpoints:
        return "d"
    if num >= 195:
        return "d"
    if num == 0:
        return "c"
    # Test defect, and keep defecting as long as they'll allow
    if (num == 5 or num >= 8) and all(choice == "c" for choice in enlist):
        return "d"
    # Recover if that goes wrong, and they were nice.
    if (num == 6 or num == 7) and all(choice == "c" for choice in enlist[:4]):
        return "c"
    # Otherwise, tit for tat.
    return enlist[-1]

Tat için 30 Göğüsler

def thirtytitsfortatfunc (num, daha fazla, eğlenceli, ben, en):
    göğüsleri = 30
    tr [-tits:] veya num> = (200-memeler) içinde "d" ise:
        dönüş "d"
    dönüş "c"

ama ya ... bir sonraki cevap acımasız bir tetikleyici ya da tat için bir şey değilse

Ben sunarım

anty

def antyfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter > 150: return "d"
    if not "c" in enlist[-2:]:
        return "d"
    if enpoints >= mypoints:
        return "d"
    else:
        return "c"

Tilki

def foxfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter > enpoints:
        return "d"
    return "c"

Tur sayısının düşman puanından büyük olup olmadığını saptar, aksi takdirde işbirliği yapar.

Oğlan

def boyfunc(counter, mypoints, enpoints, mylist, enlist):
    if counter!=0 and enlist[-1]=="c" and counter <= 194 or enpoints+10<mypoints:
        return "c"
    return "d"

İlk turda işbirliği yapar, sonra son beş turda tat ama backstabs için baştankara hareket eder ve on puan önde değilse kusurlar.

Tat için 53 göğüsleri

def fiftythreetitsfortatfunc(num, more, fun, me, en):
    tits = 53
    if "d" in en[-tits:] or num >= (200-tits):
        return "d"
    return "c"

Hepiniz bunun ne olduğunu biliyorsunuz :)

Twentyfivetitsforatat

def twentyfivetitsfortatfunc(num, more, fun, me, en):
    tits = 25
    if "d" in en[-tits:] or num >= (200-tits):
        return "d"
    return "c"

Tür göğüsleri foratat

def kindatitsfortatfunc(num, more, fun, me, en):
    tits = 54  
    if "c" in en[-tits:] or num >= (200-tits):
        return "c"
    return "d"

İhtiyatlı İhanetçi

def PrudentBetrayer(counter, mypoints, enpoints, mylist, enlist):
    # Am I ahead, even if he betrays first?
    if mypoints > enpoints + 5:
        if counter == 0:
            return "c"
        else:
            return enlist[-1]
    # Can I catch up if I betray first?
    elif mypoints + 5 > enpoints:
        if counter == 0:
            return "c"
        elif counter > 130:
            return "d"
        else:
            return "d" if "d" in enlist else "c"
    # can't win -> kill his score
    else:
        return "d"

Bir n-tits-for-a-tatbotla savaştığını varsayar . İhanete uğrayacak ve hala kazanacak puanı varsa, diğer botun önce onu vurmasına izin verir (tat için baştankara olarak oynarken.) Sadece ilk ihanet ettiğinde kazanabilirse, herhangi bir akımdan önce 130. turda ihanet eder bot. Rakibinin arkasında çok puan varsa, şüphesiz bot puanını düşürmek için defector oynayacak.

Tokalaşma

import random
def handshakefunc(num, me, him, m, en):
    handshake = "cdccd"
    # For the first few rounds, give the handshake.
    if num < len(handshake):
        if m == en:
            return handshake[num]
        return "d"
    if en[:len(handshake)] == handshake:
        if me > him:
            return "d"
        if me == him:
            return "ccd"[random.randint(0,2)]
        return "c"
    return "d"

cdccdKendi başına olup olmadığını öğrenmek için deseni ilk beş turda kullanır . Eğer öyleyse, daha fazla puana sahip botu her zaman kusurlu tutarak puanlarını en üst düzeye çıkarmaya çalışırken, diğeri her zaman işbirliği yapar. Bir düşmanla savaştığını tespit ederse, sığınmacıyı oynayacaktır.

Testlerimde, popülasyonun önemli bir bölümünü oluşturuyorsa dozu iyi buluyorum. Dozun kendisi ile savaşma şansı olmadığında, temelde bir defektöre indirgenecektir.

EDIT: Açıkça puanları, onların iyi çalışması için birçok botlar vardır. Sadece ilk birkaçıyla savaşırsa yine de kazanacak ...

Bizzaro Tetikleyici

def bizzaroTriggerfunc(round,ms,ts,mm,tm):
  if round==1:return 'c'
  if 'c' in tm:return'd'
  return 'c'

Rakibiniz sizinle işbirliği yapmadığı sürece daima işbirliği yapın, bu durumda kusurlu olursunuz. Her zaman.

FakeShake

takes advantage of handshake- does a handshake then just defects while handshake trusts it. When it meets itself, however, it does the 'real' handshake. If it meets a different bot it plays tit for tat, with a betrayal at the end. This feels kinda mean...

import random
def fakeshakefunc(num, i, d, m, enlist):
      secret_handshake="cdccdd"
      handshake= "cdccd"
      #checks if it is meeting itself
      if enlist[:len(secret_handshake)] == secret_handshake:
          if me > him:
            return "d"
          if me == him:
             return "ccd"[random.randint(0,2)]
          return "c"
      #does handshake's handshake,if the bot is not handshake or fakeshake it plays T4T
      if num < len(handshake):
            if m == enlist:
                return handshake[num]
            if i < d or num>= 198:
                return "d";
            if num == 0 or enlist[-1] == "c":
                return "c"
            else:
                return "d"
            if enlist[:len(handshake)] == handshake:
                return "d"
            if i < d or num>= 198:
                return "d";
            if num == 0 or enlist[-1] == "c":
                return "c"
            else:
                return "d"

One problem with this is that if it meets handshake and it has more points, it thinks its playing itself. I'm a newbie to python and this site (in fact this is my first answer) so make sure to tell me if I've made any stupid mistakes!