Szalony naukowiec właśnie stworzył nowy gatunek bakterii! Zdecydował się nazywać go Noblus Gentlemanus, po zaobserwowaniu jego zachowania. Jednak jego bakteriom zabrakło żywności i wypowiedziały wojnę, ponieważ są one w stanie zbierać zwłoki innych bakterii, aby uzyskać wystarczającą ilość pożywienia, aby stworzyć swoje kopie. Istnieje wiele różnych podgatunków tej bakterii, które mają różne strategie gry w Dylemat Więźnia, ich ulubioną grę. Istnieje pięć bakterii z każdego podgatunku. W Dylemacie Więźnia każdy z dwóch graczy jednocześnie wybiera wadę lub współpracuje. Jeśli jeden gracz wybierze kooperację, a drugi domyślnie, defaulter otrzymuje 2 punkty, a kooperator traci 3 punkty. Jeśli obaj gracze zdecydują się na współpracę, obaj gracze otrzymują 1 punkt. Jeśli obaj gracze wybiorą domyślne, obaj grają 1 punkt.

Będąc Szlachetnymi Panami, bakterie postanowiły stoczyć wojnę, grając w 200 rundowych gier w Dylemat Iterowanego Więźnia. Przegrany każdego pojedynku popełni samobójstwo, pozwalając zwycięzcy sklonować się. W przypadku remisu obie bakterie pozostaną przy życiu, ale żadna z nich nie będzie mogła się sklonować. Ponadto wszystkie bakterie z meczu przenoszą ponad 10% swoich punktów do następnego meczu. Klon przenosi punkty bakterii, przez które został sklonowany. Ponadto istnieje jedna szansa na dziesięć, że w każdej turze jedna bakteria zmutuje się w inny podgatunek z 0 punktami bonusowymi (jeśli otrzymam skargi na losowość tego, mogę to usunąć). Po tym, jak bakterie rozegrały wiele pojedynków równych liczbie podgatunków bakterii razy dziesięć, szalony naukowiec przypadkowo upuści szalkę Petriego, w której przebywają bakterie, i wszystkie bakterie zdobywają nowe źródła żywności, kończąc swoje pojedynki. Różni się to od zwykłego iteracyjnego dylematu więźnia, ponieważ obejmuje pojedynki 1 na 1 z punktami przeniesienia, a nie po prostu próbę zdobycia jak największej liczby punktów. To robi dużą różnicę w skuteczności danej strategii.

Każda bakteria otrzyma dane wejściowe na początku swojej tury w formacie: (numer tury, aktualne punkty, punkty wrogów, twoje poprzednie ruchy [w ciągu, używając znaku „c” do współpracy i znaku „d” do wady ], poprzednie ruchy wrogów [w tym samym formacie]).

Oto cztery przykładowe strategie, które zostaną wprowadzone. Myślę, że Defector może wygrać, nawet jeśli jest to bardzo proste.

Wet za wet

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

Współpracownik

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

Dezerter

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

Wszystkie zgłoszenia muszą mieć postać funkcji Python 2.7, przy czym nazwa jest nazwą zgłoszenia bez spacji, funcna końcu. Jeśli ktoś chciałby przesłać odpowiedź w innym języku, proszę wpisać ją w pseudo-kodzie, abym mógł przekonwertować ją na Python w odpowiedzi na twoją odpowiedź, kiedy będę miał czas, lub przekaż instrukcje dotyczące interfejsu twojego języka z moim kontrolerem, który znajduje się poniżej skonfigurowany dla wszystkich zgłoszeń od 4 czerwca.

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:

Ten konkurs jest teraz zakończony

Jeśli chcesz dodać odpowiedź, zobaczę, czy mogę przejść do dodawania tablicy wyników po wyzwaniu pod tabelą dla oryginalnych zawodników. Dodam go zaraz po zakończeniu programu testowego (prawdopodobnie 2-3 kolejne dni).

WYNIKI KOŃCOWE !!!!!

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

Wygląda więc na to, że zwycięzcą jest Perfect Gentleman. Gratulacje dla Draco18, który zdecydowanie zasługuje na swój zielony znacznik wyboru.

Idealny dżentelmen

Nie mam dobrego opisu tego bota. Natknąłem się na kilka potencjalnych optymalizacji, przetestowałem je, dostroiłem i skończyłem z bakterią, która całkowicie niszczy konkurencję. Zamiast tego skomentowałem sam kod, aby wyjaśnić, co robi.

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]

Kilka wartości wybrano arbitralnie z przetestowanymi alternatywami, a wartości tutaj są prawie optymalne w tym momencie. Wobec obecnego rozprzestrzeniania się przeciwnych frakcji, Idealny Dżentelmen osiąga całkowitą dominację (100% populacji bakterii) przez około 90% czasu (plus lub minus 3 punkty procentowe).

Nie dodałem jeszcze matematyków do moich testów, jednak ci dwaj powinni służyć tylko do karmienia istniejących strategii i nie zmieniać znacząco wyniku.

Zarządza znaczną częścią swojej kontroli poprzez podpieranie Uciekiniera, ale było to dozwolone zgodnie z zasadami (przykładowe strategie były uczciwą grą w celowanie). Posiada efekt uboczny także podpieranie Game of Thrones, ale to było niezamierzone, jak te dwie rzeczy są nie do odróżnienia na podstawie kryteriów wybrałem. Te „typy uciekinierów” mają wtedy przewagę punktową w drugiej rundzie i w rezultacie pokonują kilku kłopotliwych sąsiadów (typy N-T4T), a kiedy uzupełnią Idealnego Dżentelmena, wykorzystali swoją przewagę punktową i szybko zostali pochłonięci.

Istnieje około 5% szansy, że wszyscy Idealni Dżentelmeni sparują się z typami Uciekinierów w pierwszej rundzie i ostatecznie popełnią masowe samobójstwo. W takim przypadku jeden z typów n-T4t osiąga całkowitą dominację (196 komórek z 196). Bardzo rzadko jeden z pozostałych typów (Game of Thrones, Boy, Grimace, Sore Loser ...) nie udaje się całkowicie wyginąć i zdobyć punkt lub dwa.

Bieżąca symulacja (wciąż w kierunku do 200 gier ogółem). Wszystkie wpisy z wynikiem 0 zostały usunięte. Wygląda na to, że Game of Thrones i 54-T4T podzielili rundę (195 punktów między nimi) po wyeliminowaniu PG.

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

Tit dźgający w plecy dla Tat (z przebaczeniem)

Zasadniczo jest to Lucky Tit dla Tat (aka Tit dla Tat z przebaczeniem), który jest „rozwiązanym” optymalnym rozwiązaniem (dla pewnej wartości „szczęśliwego”), z niespodzianką. Ponieważ wiemy dokładnie, ile rund będzie trwała ta bakteria, ta bakteria dźgnie w ostatnią rundę, zapewniając w ten sposób korzystny wynik netto przeciwko każdemu innemu bakterii Tit dla bakterii Tat i Cooperator (przeciwko sobie kończy się zerowym netto, tak jakby miał współpracował). Ze względu na 10% przeniesienia daje to długoterminową przewagę.

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"

Gorzki Tat

Gorzki Tat korzysta z wszelkich prób współpracy podjętych przez wroga, gdy wróg ma przewagę punktową. Większość bakterii oferuje gałąź oliwną przynajmniej raz w ciągu 200 rund, a ponieważ Bitter Tat jest w tyle za sobą, wydobywa te 5 punktów w desperackiej próbie odzyskania.

W przeciwnym razie tit-for-tats zgodnie ze zwykłą dominującą strategią. Ponadto jest to trochę bardziej palant niż jego kuzyn i dźgnięcie w plecy wcześniej i nie oferuje przebaczenia.

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"

Gorzki Tat został zaprojektowany przez spojrzenie na zachowania innych botów przeciwko Titowi na Tat i wzorce wyrażone w tych wynikach, ale nie ma na celu jednoznacznego przeciwstawienia się tym strategiom: wciąż jest to formuła ogólnego przeznaczenia.

Extra Gorzki 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"

Bardzo gorzki, ponieważ bardzo wcześnie defekuje.

Antykapitalista

Kolejny prosty. W przypadku parzystych meczów (zaczynając od tego samego wyniku) zachowuje się bardzo podobnie do TitForTat, ale główną ideą jest próba przetrwania meczu.

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

Delikatny Odstępca

Mam tu na myśli defekt, chyba że mój wróg zazwyczaj współpracuje. Mimo to zaczyna współpracować.

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

NeoAnticapitalist

Ulepszenie antykapitalisty (a przynajmniej tak mi się wydaje). Nie widzę powodu, by współpracować w ostatniej turze. Nie widzę też powodu do współpracy, gdy jestem pewien, że mój przeciwnik nie chce.

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"

Skruszony agresor

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"

Ma to na celu „nadążyć” za Defekterem, za każdym razem uciekając przed nim, a także pokonać strategie oparte na wcieraniu się za tatę.

Podstawową ideą jest to, że zaczynamy od defensywy, ale jeśli przeciwnik współpracował w pierwszej turze, wówczas współpracujemy dwukrotnie, aby uniknąć cyklu wzajemnej dyskryminacji, unikając w ten sposób zbyt dużej kary punktowej. (Jeśli jednak przeciwnik później ulegnie defektowi, nie sami przerywamy cykl; sprawimy, że zrobi to i prawdopodobnie przegra grę.) Następnie na koniec gry wybieramy losowy czas w ciągu ostatnich 5 zwrotów dźgnął wroga, dając nam jeszcze jedną wadę od nich, a tym samym oznacza, że ​​dopóki nie byliśmy zbyt daleko w tyle za punktami przeniesienia, ostatecznie wygrywamy, nie poświęcając wiele pod względem przeniesienia w tym procesie . (Losowanie przedziału czasu oznacza, że ​​najprawdopodobniej wejdziemy najpierw w dźgnięcie w plecy, a także, że tej strategii nie da się „dostroić”, dążąc do dźgnięcia go w jedną turę wcześniej).

Ponury spust

Uproszczony bot, aby spróbować wypełnić konkurencję

Będzie współpracował, chyba że wróg się zepsuje, w takim przypadku zepsuje się wybaczająco

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

wydaje się, że to nie działa z powodu ntitsfortat meta wczesnego defektowania

Gra o tron

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"

Chodzi o to, że nigdy nie możesz przegrać zdradzając, więc jedynym powodem do współpracy jest to, że jesteś w tyle. Ma również ogólne ramy dla innych odpowiedzi T4T (bez żadnego wybaczenia, ponieważ nie jestem pewien, czy ma to wiele sensu z innymi rywalami tutaj).

Aby wygrać, trzeba zmienić kolej na zdradę, ponieważ w wyrównanym wyścigu T4Ter, który pierwszy zdradzi, wygra, ale przeciwko bardzo współpracującemu botowi stracisz punkty życia. Nie jestem pewien właściwego wierzchołka dla tej skoczni, więc wybieram 140. Nie zdziwiłbym się, gdyby było znacznie wcześniej.

Jeśli skończy się to na szalce Petriego z T4Terem, który zdradza wcześniej, lub dezerterem (tj. 146 T4T), to zależy całkowicie od tego, czy GoT jest już przed nami (pozostanie na wprost), czy też jest parzysty / GoT jest z tyłu , w takim przypadku wygra wczesny zdrajca.

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"

Jestem pewien, że gdzieś przeczytałem, że tit for tat to najlepsza strategia. Postanowiłem umożliwić innym programom wykupienie się tylko po to, by dodać trochę urozmaicenia. Teraz z odpowiednim generatorem liczb losowych (daje mi to przewagę, prawda?).

Słoń

Słoń nigdy nie zapomina!

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"

Słoń patrzy na historię walki i próbuje dowiedzieć się, co zaplanował wróg. Patrzy zarówno na swoje ruchy, jak i na wrogów!

Próbuje znaleźć najdłuższą równoległą grupę, która pasuje do tego, co właśnie się wydarzyło, i bierze to, co wróg zrobił zaraz po tym.

Jeśli nie będzie w stanie tego rozwiązać, Słoń po prostu będzie współpracował, ponieważ przyjaźń jest zawsze odpowiedzią.

Jeśli sądzi, że jego przeciwnik popełni błąd, on również popełni błąd, nie chcąc stracić ciężko zdobytych punktów.

Jeśli sądzi, że jego przeciwnik będzie współpracował, ale jego mniej niż lub dokładnie 6 punktów prowadzi, to odejdzie, by zdobyć przyczółek.

I wreszcie, jeśli myśli, że jego przeciwnik będzie współpracował i ma silną przewagę, będzie współpracował.

54 cycki dla tat

def fiftyfourtitsfortatfunc (num, more, fun, me, en):
    cycki = 54
    jeśli „d” w en [-tits:] lub num> = (200-tits):
        zwróć „d”
    zwróć „c”

Miły facet

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"

Próbuje przewidzieć wyniki przeciwników, patrząc na historię. Na przykład, jeśli ostatnie ruchy były ( cwrogiem d), próbuje znaleźć ostatnie wystąpienie dokładnie tych samych ruchów.

Hackman [zdyskwalifikowany zgodnie z oczekiwaniami]

Ok, ten prawdopodobnie zostanie wykluczony z konkursu, ale naprawdę mam ochotę go wypróbować:

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"

Tutaj biorę za podstawę BackstabbingTitForTat, który okazał się najlepszy w moich symulacjach. Poza tym opiera się na nieużywanym symbolu "#"(dlatego mówię, że prawdopodobnie zostanie wykluczony).

Teraz pozwól mi wyjaśnić warunki tutaj:

1.: Upewnij się, że dwóch Hackmanów współpracuje, jeśli coś pójdzie nie tak.

2.: Jeśli mam przegrać z innym botem, przynajmniej spraw, aby stracił tyle punktów, ile to możliwe, więc nie jest to potem wielki wróg.

3.: Zdradź jedną turę wcześniej, więc wygrywa vs dźgnięcie w plecy

użycie „#” zamiast „d” powoduje, że dostaję 0 punktów zamiast -1, a także komunikuję się z innym Hackmanem, który ma mniej punktów, więc przestaje defektować.

Bizzaro

Robi dokładne przeciwieństwo tit dla tat. Kiedy ktoś jest dla niego miły, okazuje swoją miłość, będąc złym, a gdy ktoś jest podły, okazuje zemstę, będąc dobrym. Mocno oparty na sikorze na tat.

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

6 cycki dla tat

def sixtitsforatatfunc (num, more, fun, me, en):
    jeśli „d” w en [-6:] lub num> = 194:
        zwróć „d”
    zwróć „c”

Odbywa się Tit do wyścigu zbrojeń Tat :)

Dziesięć cycki za tat

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

Defekty wcześniej, a także defekty, jeśli jego przeciwnik wykonał defekt w ciągu ostatnich dziesięciu tur.

CopyFirst

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

Defektuje to pierwszą rundę, a następnie robi wszystko, co przeciwnik zrobił w pierwszej rundzie, aż do 197 rundy, kiedy to dźgnie w plecy.

Czterdzieści cycki dla tat

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

Jeśli przeciwnik ucieka w ciągu ostatnich 40 tur, wada, w przeciwnym razie współpracuj. Dźgnięcie w plecy w ciągu ostatnich 50 tur.

Three Tits for a Tat

Jeśli przeciwnik zbankrutuje w ciągu ostatnich 3 tur, wada, w przeciwnym razie współpracuj. Dźgnięcie w plecy w ciągu ostatnich 5 tur. Ten program ukradł prowadzenie z Tit for Two Tats wąskim marginesem.

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"

Pięć ciał dla tat

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

Jeśli nie możesz zrozumieć, co on robi, jesteś idiotą. Również dźgnięcie w plecy jedną rundę wcześniej.

Grymas

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

Każdy inny D.

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

Każdy inny C

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

Przewidywalni matematycy:

Młody matematyk

Nowość w surowości świata

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

Starszy matematyk

Bardziej doświadczony w tych sprawach

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

Wątpię, czy któryś z nich dobrze sobie poradzi, ale przynajmniej dodadzą innym sposoby na zdobycie punktów!

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

Tit For Tat, ale losowo. To nie wygra żadnych nagród (chyba że mam szczęście). Teraz z losowymi liczbami generowanymi z właściwego źródła.

Exploitive Tat

Exploitive Tat próbuje grać w następujące strategie:

• Wada, gdy jest z tyłu. To jedyny sposób, aby to nadrobić.

• Współpracuj przeciwko tit-for-tat i podobnym strategiom. To jedyny sposób na uzyskanie dobrego wyniku długoterminowego.

• Wada wobec zawsze współpracujących i innych ludzi.

• Uszkodzenie 5 rund wcześniej.

Oto 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]

30 cycki za tat

def thirtytitsfortatfunc (num, more, fun, me, en):
    cycki = 30
    jeśli „d” w en [-tits:] lub num> = (200-tits):
        zwróć „d”
    zwróć „c”

ale co jeśli ... następna odpowiedź nie była ponurym wyzwalaczem ani czymś na tat

Prezentuje

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"

Lis

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

Wady, jeśli liczba zaokrągleń jest większa niż liczba wrogów, współpracuje inaczej.

Chłopiec

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"

Współpracuje w pierwszej rundzie, a następnie działa na miareczkowanie za tat, ale dźgnięcie w plecy w ostatnich pięciu rundach i powoduje defekty, jeśli nie ma dziesięciu punktów do przodu.

53 cycki za tat

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

Wszyscy wiecie co to jest :)

Twentyfivetitsforatat

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

Rodzaj cyckiforatat

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

Roztropna zdrajca

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"

Zakłada, że ​​walczy z n-tits-for-a-tatbotem. Jeśli ma wynik do zdradzenia i nadal wygrywa, pozwoli drugiemu botowi trafić go jako pierwszy (grając jako tit na tat.) Jeśli wygra tylko wtedy, gdy zdradzi pierwszy, zdradzi się w rundzie 130, na długo przed jakimkolwiek prądem nerw. Jeśli jest dużo punktów za przeciwnikiem, po prostu zagra w defektora, próbując obniżyć wynik niczego nie podejrzewającego bota.

Uścisk dłoni

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"

Używa wzoru cdccdz pierwszych pięciu rund, aby dowiedzieć się, czy jest on sam. Jeśli tak, spróbuje zmaksymalizować swoje punkty, utrzymując bota z większą liczbą punktów zawsze wadliwym, podczas gdy drugi zawsze będzie współpracował. Jeśli stwierdzi, że walczy z wrogiem, zagra uciekiniera.

W moich testach uważam, że dobrze dawkuje, jeśli stanowi znaczną część populacji. Kiedy dawka nie będzie miała szansy na samodzielną walkę, zostanie zasadniczo zredukowana do uciekającego.

EDYCJA: Wyraźnie z wyników, są dla wielu botów, aby to działało dobrze. Nadal wygra, jeśli walczy tylko z kilkoma najlepszymi ...

Bizzaro Trigger

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

Zawsze współpracuj, chyba że Twój przeciwnik kiedykolwiek z tobą współpracuje, w takim przypadku masz wadę. Zawsze.

FakeShake

wykorzystuje uścisk dłoni - wykonuje uścisk dłoni, a następnie po prostu ulega uszkodzeniu, podczas gdy uścisk dłoni mu ufa. Kiedy jednak się spotyka, robi „prawdziwy” uścisk dłoni. Jeśli spotka innego bota, gra tit za tat, ze zdradą na końcu. To wydaje się w pewnym sensie ...

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"

Jednym z problemów jest to, że jeśli spotyka uścisk dłoni i ma więcej punktów, myśli, że gra sama. Jestem nowicjuszem w Pythonie i tej stronie (w rzeczywistości jest to moja pierwsza odpowiedź), więc upewnij się, że popełniłem głupie błędy!