Seorang ilmuwan gila baru saja menciptakan spesies bakteri baru! Dia telah memutuskan untuk menamakannya Noblus Gentlemanus, setelah mengamati perilakunya. Namun, bakteri-nya telah kehabisan makanan, dan telah menyatakan perang, karena mereka dapat memanen mayat bakteri lain untuk makanan yang cukup untuk membuat salinan dari diri mereka sendiri. Ada sejumlah subspesies berbeda dari bakteri ini, yang memiliki strategi berbeda dalam memainkan Prisoner's Dilemma, game favorit mereka. Ada lima bakteri dari masing-masing subspesies yang berbeda. Dalam Dilema Tahanan, masing-masing dari dua pemain secara bersamaan memilih cacat atau bekerja sama. Jika satu pemain memilih bekerja sama dan yang lainnya memilih default, yang kalah mendapat 2 poin, dan kooperator kehilangan 3 poin. Jika kedua pemain memilih bekerja sama, kedua pemain mendapatkan 1 poin. Jika kedua pemain memilih default, kedua pemain kehilangan 1 poin.

Menjadi Noble Gentlemen, bakteri ini memutuskan untuk bertarung dalam perang ini dengan memainkan 200 pertandingan panjang Dilema Penjara Iterated. Yang kalah dari setiap duel akan bunuh diri, yang memungkinkan pemenang untuk mengkloning dirinya sendiri. Jika terjadi ikatan, kedua bakteri akan tetap hidup, tetapi keduanya tidak akan dapat mengkloning dirinya sendiri. Selain itu, semua bakteri dari kecocokan membawa lebih dari 10% poin mereka ke kecocokan berikutnya. Klon membawa poin-poin bakteri yang dikloningnya. Juga, ada satu dari sepuluh peluang setiap belokan bahwa satu bakteri akan bermutasi menjadi subspesies lain, dengan 0 poin bonus (jika saya menerima keluhan tentang keacakan ini, saya dapat menghapusnya). Setelah bakteri memainkan sejumlah duel ini sama dengan jumlah subspesies bakteri kali sepuluh, ilmuwan gila itu secara tidak sengaja menjatuhkan cawan petri tempat bakteri itu berada, dan semua bakteri memperoleh sumber makanan baru, mengakhiri duel mereka. Ini berbeda dari kontes dilema napi biasa yang diulang, karena melibatkan duel 1v1 dengan poin sisa, bukan hanya berusaha untuk mendapatkan poin terbanyak secara keseluruhan. Ini membuat perbedaan besar dalam seberapa efektif strategi yang diberikan.

Setiap bakteri akan menerima input pada awal gilirannya dalam format: (nomor giliran, poin saat ini, poin musuh, gerakan Anda sebelumnya [dalam string, menggunakan karakter "c" untuk bekerja sama, dan karakter "d" untuk cacat) ], musuh bergerak sebelumnya [dalam format yang sama]).

Berikut adalah empat strategi sampel yang akan dimasukkan. Saya benar-benar berpikir bahwa Defector mungkin menang, meskipun itu sangat sederhana.

Gayung bersambut

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"])

Koperator

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

Penyeberang

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

Semua kiriman harus dalam bentuk fungsi Python 2.7, dengan nama yang menjadi nama kiriman tanpa spasi, dengan funcdi bagian akhir. Jika seseorang ingin mengirimkan jawaban dalam bahasa yang berbeda, silakan masukkan dalam pseudo-code, bagi saya untuk mengonversi ke Python dalam edit ke jawaban Anda begitu saya punya waktu, atau beri saya instruksi untuk menghubungkan bahasa Anda dengan pengontrol saya yang ditemukan di bawah ini diatur untuk semua pengiriman pada 4 Juni.

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:

Kontes ini sekarang Selesai

Jika Anda ingin menambahkan jawaban, saya akan melihat apakah saya bisa menambahkan papan skor pasca-tantangan di bawah yang untuk kontestan asli. Saya akan menambahkan itu segera setelah program pengujian selesai (mungkin 2-3 hari lagi).

SKOR AKHIR !!!!!

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

Jadi, tampaknya Perfect Gentleman adalah pemenangnya. Selamat kepada Draco18, yang jelas layak mendapatkan tanda centang hijau.

Tuan yang Sempurna

Saya tidak memiliki deskripsi yang baik untuk bot ini. Saya menemukan beberapa potensi optimasi, mengujinya, menyelaraskan, dan berakhir dengan bakteri yang benar - benar menghancurkan kompetisi. Sebagai gantinya, saya telah berkomentar kode itu sendiri untuk menjelaskan apa yang dilakukannya.

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]

Beberapa nilai dipilih secara sewenang-wenang dengan alternatif yang diuji dan nilai-nilai di sini hampir-optimal pada saat ini. Terhadap penyebaran faksi lawan saat ini, The Perfect Gentleman mencapai dominasi penuh (100% populasi bakteri) sekitar 90% dari waktu (plus atau minus 3 poin persentase).

Saya belum menambahkan di Matematikawan untuk tes saya, namun keduanya hanya berfungsi untuk memberi makan strategi yang ada dan tidak sangat mengubah hasil.

Ia mengelola sebagian besar kendalinya dengan menopang Defector, tetapi itu diizinkan sesuai aturan (contoh strategi adalah permainan yang adil untuk penargetan). Ini memiliki efek samping juga menopang Game of Thrones, tapi itu tidak disengaja karena keduanya tidak bisa dibedakan berdasarkan kriteria yang saya pilih. "Tipe pembelot" itu kemudian memiliki keunggulan poin di babak 2 dan mengeluarkan beberapa tetangga yang merepotkan sebagai hasilnya (tipe N-T4T) dan ketika mereka memperbaiki The Perfect Gentleman, mereka telah menggunakan keunggulan poin mereka dan dengan cepat dikonsumsi.

Ada kemungkinan sekitar 5% bahwa semua Tuan-tuan Sempurna berakhir berpasangan dengan tipe-Pembela di babak pertama dan akhirnya bunuh diri massal. Dalam hal ini, salah satu tipe n-T4t mencapai dominasi total (196 sel dari 196). Sangat jarang salah satu dari tipe lain (Game of Thrones, Boy, Grimace, Sore Loser ...) berhasil tidak sepenuhnya punah dan mencetak satu atau dua poin.

Simulasi saat ini (masih dalam proses menuju total 200 game). Semua entri dengan skor 0 dihapus. Sepertinya Game of Thrones dan 54-T4T membagi satu putaran (195 poin di antara mereka) setelah PG tersingkir.

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

Backstabbing Tit for Tat (with Forgiveness)

Ini pada dasarnya adalah Lucky Tit untuk Tat (alias Tit untuk Tat with Forgiveness) yang merupakan solusi optimal "terpecahkan" (untuk beberapa nilai "lucky"), dengan twist. Seperti yang kita tahu persis berapa putaran permainan yang akan bertahan, bakteri ini menusuk kembali pada putaran final sehingga memastikan hasil yang menguntungkan neto terhadap bakteri Tit dan Kooperator lainnya (melawan dirinya sendiri berakhir dengan nol bersih, sama seperti jika itu memiliki bekerja sama). Karena akumulasi 10%, ini menghasilkan keuntungan jangka panjang.

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"

Tat Pahit

Bitter Tat mengambil keuntungan dari setiap upaya kerjasama yang diberikan oleh musuh ketika musuh unggul dalam poin. Kebanyakan bakteri menawarkan cabang zaitun setidaknya sekali selama 200 putaran, dan karena Bitter Tat berada di belakang keseluruhan, itu akan memerah susu 5 poin dalam upaya putus asa untuk pemulihan.

Kalau tidak, itu sesuai dengan strategi dominan yang biasa. Juga, itu sedikit lebih brengsek daripada sepupunya dan menusuk putaran sebelumnya dan tidak menawarkan pengampunan.

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"

Bitter Tat dirancang dengan melihat perilaku bot lain terhadap Tit for Tat dan pola yang diungkapkan dalam hasil tersebut, tetapi tidak dirancang untuk secara eksplisit melawan strategi tersebut: itu masih merupakan formula tujuan umum.

Tat Tambahan Pahit

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 pahit dengan membelot ekstra dini.

Anticapitalist

Satu lagi yang sederhana. Untuk pertandingan genap (mulai dari skor yang sama) berperilaku sangat mirip dengan TitForTat, tetapi ide utamanya adalah mencoba bertahan dari pertandingan.

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

Pembangkang Lembut

Gagasan saya di sini adalah membelot kecuali jika musuh saya biasanya bekerja sama. Padahal, itu mulai bekerja sama.

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

NeoAnticapitalist

Sebuah perbaikan dari Anticapitalist (atau jadi saya pikir). Saya tidak melihat alasan untuk berkolaborasi pada giliran terakhir. Saya juga tidak melihat alasan untuk berkolaborasi ketika saya cukup yakin lawan saya tidak akan melakukannya.

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"

Penyerang penyesalan

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"

Ini dirancang untuk "mengikuti" dengan Defector, dengan membelot setiap kali melawannya, dan juga untuk mengalahkan strategi berbasis tit-for-tat.

Ide dasarnya adalah bahwa kita mulai dengan membelot, tetapi jika lawan bekerja sama, giliran 1, kita kemudian bekerja sama dua kali untuk menghindari siklus saling tuding, sehingga menghindari penalti poin yang terlalu besar. (Namun, jika lawan cacat di kemudian hari, kami tidak memutus siklus sendiri; kami akan membuat mereka melakukannya dan kemungkinan akan kehilangan permainan sebagai hasilnya.) Kemudian pada akhir pertandingan, kami memilih waktu acak dalam 5 putaran terakhir untuk menikam musuh, memberi kita satu pembelotan lebih dari mereka dan dengan demikian berarti bahwa selama kita tidak terlalu jauh tertinggal dalam poin akumulasi, kita akhirnya menang, tanpa mengorbankan banyak dalam hal akumulasi dalam proses . (Mengacak periode waktu berarti bahwa kita sangat mungkin untuk masuk terlebih dahulu dengan backstab, juga bahwa strategi ini tidak dapat "disetel melawan" dengan bertujuan untuk menusuk kembali satu putaran sebelumnya.)

Grim Trigger

Bot sederhana, untuk mencoba dan mengisi kompetisi

Itu akan bekerja sama, kecuali musuh cacat, dalam hal ini ia cacat tanpa ampun

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

baik, sepertinya ini tidak berhasil karena meta ntitsfortat membelot awal

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"

Gagasan di sini adalah bahwa Anda tidak akan pernah kalah dengan mengkhianati, jadi satu-satunya alasan untuk bekerja sama adalah jika Anda berada di belakang. Ini juga memiliki kerangka kerja umum dari jawaban T4T lainnya (tanpa pengampunan, karena saya tidak yakin apakah ada banyak gunanya dengan pesaing lain di sini).

Pergantian untuk mengkhianati mungkin perlu diubah untuk menang, karena dalam balapan genap, T4Ter yang mengkhianati pertama akan menang, tetapi melawan bot yang sangat kooperatif, Anda akan kehilangan beberapa poin seumur hidup. Saya tidak yakin puncak yang tepat untuk bukit ini, jadi saya hanya pergi untuk 140. Saya tidak akan terkejut jika itu jauh lebih awal.

Jika ini berakhir di cawan petri dengan T4Ter yang mengkhianati sebelumnya atau pembelot (yaitu 146 T4T), maka itu sepenuhnya tergantung pada apakah GoT sudah di depan (itu akan tetap di depan) atau jika mereka bahkan / GoT ada di belakang , dalam hal ini pengkhianat awal akan menang.

Lucky Tit For 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"

Saya cukup yakin saya membaca di suatu tempat bahwa gayung bersambut adalah strategi terbaik. Saya memutuskan untuk memungkinkan program lain menebus diri mereka sendiri hanya untuk menambah variasi. Sekarang dengan generator nomor acak yang tepat (itu memberi saya keuntungan kan?).

Gajah

Gajah tidak pernah lupa!

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"

Gajah melihat sejarah pertarungan, dan mencoba mencari tahu apa yang telah direncanakan musuh. Dia melihat gerakan dan musuhnya!

Dia mencoba menemukan kelompok konkuren terpanjang yang cocok dengan apa yang baru saja terjadi, dan mengambil apa yang musuh lakukan setelah itu.

Jika dia tidak bisa menyelesaikannya, Gajah hanya akan Bekerja Sama, karena persahabatan selalu jawabannya.

Jika dia berpikir lawannya akan cacat, dia juga akan membelot, tidak ingin kehilangan poin yang diperolehnya dengan susah payah.

Jika dia berpikir lawannya akan bekerja sama, tetapi kurang dari atau tepat 6 poin memimpin, maka dia akan membelot, untuk mendapatkan pijakan.

Dan terakhir, jika dia berpikir lawannya akan bekerja sama, dan dia memiliki keunggulan yang kuat, dia akan bekerja sama.

54 Tits untuk Tat

def fiftyfourtitsfortatfunc (num, more, fun, me, en):
    payudara = 54
    jika "d" dalam id [-tits:] atau num> = (200-payudara):
        kembalikan "d"
    kembalikan "c"

Orang baik

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"

Mencoba memprediksi hasil lawan dengan melihat sejarah. Misalnya, jika gerakan terakhir adalah (c , musuh d), ia mencoba untuk menemukan kejadian terakhir dari gerakan yang sama persis.

Hackman [didiskualifikasi seperti yang diharapkan]

Ok, yang ini mungkin akan dikesampingkan dari kontes, tapi saya benar-benar ingin mencobanya:

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"

Di sini saya menggunakan BackstabbingTitForTat yang terbukti menjadi yang terbaik dalam simulasi saya. Juga, ini sangat berbasis dalam menggunakan simbol yang tidak digunakan"#" (itu sebabnya saya mengatakan itu mungkin akan dikesampingkan).

Sekarang izinkan saya menjelaskan kondisinya di sini:

1: Pastikan dua peretas bekerja sama jika ada masalah.

2: Jika aku akan kalah melawan bot yang berbeda, setidaknya membuatnya kehilangan poin sebanyak mungkin, jadi itu bukan musuh besar setelahnya.

3: Mengkhianati satu putaran sebelumnya, jadi menang vs pengkhianatan

menggunakan "#" bukannya "d" membuat saya mendapatkan 0 poin, bukan -1 dan juga berkomunikasi dengan Hackman lain yang memiliki poin lebih sedikit, jadi dia berhenti membelot.

Bizzaro

Apakah kebalikan dari gayung bersambut. Ketika seseorang baik padanya dia menunjukkan cintanya dengan menjadi jahat, dan ketika seseorang jahat dia menunjukkan balas dendam dengan menjadi baik. Sangat berdasarkan pada gayung bersambut.

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

6 Tits untuk Tat

def sixtitsforatatfunc (num, more, fun, me, en):
    jika "d" dalam id [-6:] atau num> = 194:
        kembalikan "d"
    kembalikan "c"

Gayung untuk lomba lengan Tat sedang terjadi :)

Sepuluh Tits untuk Tat

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

Cacat sebelumnya, dan juga cacat jika lawannya telah membelot dalam sepuluh putaran terakhir.

CopyFirst

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

Ini merusak babak pertama, kemudian melakukan apa pun yang dilakukan lawan di babak pertama, hingga babak ke-197, ketika melakukan backstab.

Empat Puluh Tits untuk Tat

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

Jika lawan membelot dalam 40 putaran terakhir, cacat, jika tidak bekerja sama. Backstab pada 50 putaran terakhir.

Tiga Tits untuk Tat

Jika lawan membelot dalam 3 putaran terakhir, cacat, jika tidak bekerja sama. Backstab pada 5 putaran terakhir. Program ini telah mencuri keunggulan dari Tit for Two Tats dengan selisih yang kecil.

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"

Lima Tits untuk Tat

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

Jika Anda tidak tahu apa yang dilakukan orang ini, Anda idiot. Juga backstab satu putaran sebelumnya.

Meringis

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

Setiap Lainnya D

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

Setiap Lainnya C

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

Matematikawan yang bisa ditebak:

Ahli Matematika Muda

Baru dalam dunia yang keras

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

Mathematitian yang lebih tua

Lebih berpengalaman dalam hal ini

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

Saya ragu salah satu dari ini akan berhasil, tetapi setidaknya mereka akan menambahkan cara bagi orang lain untuk mendapatkan poin!

Tit Acak Untuk Tat

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"

Gayung Untuk Tat, tetapi secara acak. Ini tidak akan memenangkan hadiah apa pun (kecuali saya benar-benar beruntung). Sekarang dengan angka acak yang dihasilkan dari sumber yang tepat.

Tat Eksploitatif

Tat Eksploitatif mencoba memainkan strategi berikut:

• Cacat saat di belakang. Ini satu-satunya cara untuk mengejar ketinggalan.

• Bekerjasama melawan tit-for-tat dan strategi serupa. Ini satu-satunya cara untuk mendapatkan skor jangka panjang yang bagus.

• Cacat terhadap selalu-kooperator dan orang bodoh lainnya.

• Cacat 5 putaran lebih awal.

Ini kodenya:

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]

30 Tits untuk Tat

def fiftytitsfortatfunc (num, more, fun, me, en):
    payudara = 30
    jika "d" dalam id [-tits:] atau num> = (200-payudara):
        kembalikan "d"
    kembalikan "c"

tetapi bagaimana jika ... jawaban berikutnya bukan pemicu suram atau sesuatu untuk tat

Saya hadir

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"

Rubah

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

Cacat jika angka bulat lebih besar dari poin musuh, bekerja sama sebaliknya.

Anak laki-laki

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"

Bekerja sama pada ronde pertama, kemudian bertindak untuk mendapatkan tit tetapi backstab pada lima ronde terakhir, dan cacat jika tidak sepuluh poin di depan.

53 payudara untuk tat

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

Anda semua tahu apa ini :)

Dua puluh lima untuk catatan

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

Agak payudaranya direkam

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

Pengkhianat yang bijaksana

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"

Menganggap itu melawan n-tits-for-a-tatbot. Jika ada skor yang harus dikhianati dan masih menang, itu akan membiarkan bot yang lain memukulnya terlebih dahulu (bermain sebagai gayung bersambut). bot Jika ada banyak poin di belakang lawannya, itu hanya akan bermain pembelot dalam upaya untuk menurunkan skor bot yang tidak curiga.

Jabatan tangan

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"

Gunakan polanya cdccd pada lima putaran pertama, untuk mencari tahu apakah itu dengan sendirinya. Jika demikian, ia akan mencoba untuk memaksimalkan poin dengan memiliki bot dengan lebih banyak poin yang selalu cacat, sementara yang lain selalu bekerja sama. Jika ternyata ia melawan musuh, ia akan memainkan pembelot.

Dalam tes saya, saya merasa dosisnya baik jika itu merupakan bagian penting dari populasi. Ketika dosisnya tidak memiliki kesempatan untuk bertarung sendiri, itu pada dasarnya akan dikurangi menjadi pembelot.

EDIT: Jelas dari skor, mereka ke banyak bot agar ini berfungsi dengan baik. Masih akan menang jika bertarung hanya dengan beberapa ...

Bizzaro Trigger

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

Selalu bekerja sama, kecuali lawan Anda pernah bekerja sama dengan Anda, dalam hal ini Anda cacat. Selalu.

Goyang Palsu

mengambil keuntungan dari jabat tangan - melakukan jabat tangan kemudian hanya cacat sementara jabat tangan mempercayainya. Namun, ketika itu bertemu dengan dirinya sendiri, itu adalah jabat tangan yang 'nyata'. Jika memenuhi bot yang berbeda ia memainkan gayung bersambut, dengan pengkhianatan di akhir. Ini terasa agak kejam ...

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"

Satu masalah dengan ini adalah bahwa jika bertemu jabat tangan dan memiliki lebih banyak poin, ia berpikir itu bermain sendiri. Saya seorang pemula untuk python dan situs ini (sebenarnya ini adalah jawaban pertama saya) jadi pastikan untuk memberi tahu saya jika saya membuat kesalahan bodoh!