Ein verrückter Wissenschaftler hat gerade eine neue Bakterienart geschaffen! Er hat beschlossen, es Noblus Gentlemanus zu nennen, nachdem man sein Verhalten beobachtet hat. Seine Bakterien haben jedoch keine Nahrung mehr und haben den Krieg erklärt, da sie in der Lage sind, die Leichen anderer Bakterien für genügend Nahrung zu ernten, um Kopien von sich selbst anzufertigen. Es gibt eine Reihe verschiedener Unterarten dieses Bakteriums, die unterschiedliche Strategien haben, um Prisoner's Dilemma, ihr Lieblingsspiel, zu spielen. Es gibt fünf Bakterien aus verschiedenen Unterarten. Im Gefangenendilemma wählt jeder der beiden Spieler gleichzeitig entweder einen Defekt oder kooperiert. Wenn ein Spieler kooperiert und der andere Standard wählt, erhält der Schuldner 2 Punkte und der Kooperator verliert 3 Punkte. Wenn beide Spieler kooperieren, erhalten beide einen Punkt. Wenn beide Spieler die Standardeinstellung wählen, verlieren beide Spieler 1 Punkt.

Als edle Gentlemen haben die Bakterien beschlossen, diesen Krieg zu führen, indem sie 200 Runden lang das Dilemma des wiederholten Gefangenen gespielt haben. Der Verlierer eines jeden Duells wird Selbstmord begehen und dem Sieger erlauben, sich selbst zu klonen. Bei einem Unentschieden bleiben beide Bakterien am Leben, können sich jedoch nicht selbst klonen. Darüber hinaus tragen alle Bakterien eines Matches mehr als 10% ihrer Punkte für das nächste Match. Ein Klon überträgt die Punkte des Bakteriums, von dem er geklont wurde. Es gibt auch eine Wahrscheinlichkeit von eins zu zehn, dass ein Bakterium in eine andere Unterart mutiert, mit 0 Bonuspunkten (wenn ich Beschwerden über die Zufälligkeit davon erhalte, kann ich es entfernen). Nachdem die Bakterien eine Anzahl dieser Duelle gespielt haben, die der Anzahl der Unterarten von Bakterien mal zehn entspricht, lässt der verrückte Wissenschaftler versehentlich die Petrischale fallen, in der sich die Bakterien befinden. und alle Bakterien erwerben neue Nahrungsquellen und beenden ihre Duelle. Dies unterscheidet sich von einem gewöhnlichen iterierten Gefangenen-Dilemma-Wettbewerb, da es sich um 1v1-Duelle mit Übertragungspunkten handelt, anstatt nur zu versuchen, die meisten Punkte insgesamt zu erzielen. Dies macht einen großen Unterschied darin, wie effektiv eine bestimmte Strategie ist.

Jedes Bakterium erhält zu Beginn seines Zuges Eingaben in folgendem Format: (Zugnummer, aktuelle Punkte, Feindpunkte, Ihre vorherigen Züge [in einer Zeichenfolge, wobei das Zeichen "c" für die Zusammenarbeit und das Zeichen "d" für den Defekt verwendet wird ], Gegner vorherige Züge [im gleichen Format]).

Hier sind vier Beispielstrategien, die eingegeben werden. Ich denke tatsächlich, dass Defector gewinnen könnte, obwohl es extrem einfach ist.

Wie du mir so ich dir

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

Mitarbeiter

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

Überläufer

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

Alle Einreichungen müssen die Form einer Python 2.7-Funktion haben, wobei der Name der Name der Einreichung ohne Leerzeichen funcam Ende ist. Wenn jemand eine Antwort in einer anderen Sprache einreichen möchte, geben Sie diese bitte in einem Pseudocode ein, damit ich sie in einem Bearbeitungsschritt nach Python konvertieren kann, sobald ich Zeit habe, oder geben Sie mir Anweisungen zur Verbindung Ihrer Sprache mit meinem Controller wird im Folgenden für alle Einsendungen ab dem 4. Juni eingerichtet.

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:

Dieser Wettbewerb ist nun beendet

Wenn Sie eine Antwort hinzufügen möchten, werde ich sehen, ob ich es schaffen kann, eine Anzeigetafel nach der Herausforderung unter der für die ursprünglichen Teilnehmer einzufügen. Ich werde das hinzufügen, sobald das Testprogramm beendet ist (wahrscheinlich 2-3 weitere Tage).

SCHLUSSPUNKTE !!!!!

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

Es scheint also, dass Perfect Gentleman der Gewinner ist. Herzlichen Glückwunsch an Draco18, der definitiv sein grünes Häkchen verdient hat.

Der perfekte Gentleman

Ich habe keine gute Beschreibung für diesen Bot. Ich stolperte über ein paar mögliche Optimierungen, testete sie, stimmte sie fein ab und landete bei einem Bakterium, das die Konkurrenz völlig zerstört . Stattdessen habe ich den Code selbst kommentiert, um zu erklären, was er tut.

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]

Mehrere Werte wurden willkürlich mit getesteten Alternativen ausgewählt und die Werte hier sind zu diesem Zeitpunkt nahezu optimal. Gegen die derzeitige Verbreitung gegnerischer Fraktionen erlangt The Perfect Gentleman in etwa 90% der Fälle eine vollständige Dominanz (100% der Bakterienpopulation) (plus oder minus 3 Prozentpunkte).

Ich habe meine Tests noch nicht zu den Mathematikern hinzugefügt, aber diese beiden sollten nur dazu dienen, bestehende Strategien zu fördern und das Ergebnis nicht wesentlich zu verändern.

Ein Großteil der Kontrolle wird zwar über das Aufsetzen von Defector verwaltet, dies war jedoch gemäß den Regeln zulässig (die Beispielstrategien waren ein faires Spiel für das Targeting). Es hat den Nebeneffekt , dass es auch Game of Thrones unterstützt, aber das war unbeabsichtigt, da die beiden nach den von mir gewählten Kriterien nicht zu unterscheiden sind. Diese "Überläufer-Typen" haben dann in Runde 2 einen Punktevorteil und schlagen infolgedessen mehrere problematische Nachbarn aus (die N-T4T-Typen). Wenn sie erneut auf The Perfect Gentleman treffen, haben sie ihren Punktevorteil aufgebraucht und sind schnell verbraucht.

Es besteht eine ungefähre Wahrscheinlichkeit von 5%, dass alle Perfect Gentlemen in der ersten Runde mit Defector-Typen gepaart werden und am Ende einen Massenselbstmord begehen. In diesem Fall erreicht einer der n-T4t-Typen eine vollständige Dominanz (196 Zellen von 196). Sehr selten schafft es einer der anderen Typen (Game of Thrones, Boy, Grimace, Sore Loser ...), nicht vollständig ausgestorben zu sein und ein oder zwei Punkte zu holen.

Aktuelle Simulation (noch in Bearbeitung für insgesamt 200 Spiele). Alle Einträge mit der Wertung 0 wurden entfernt. Sieht aus wie Game of Thrones und 54-T4T, die eine Runde geteilt haben (195 Punkte dazwischen), nachdem PG eliminiert wurde.

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 für Tat (mit Vergebung)

Dies ist im Grunde Lucky Tit for Tat (auch bekannt als Tit for Tat with Forgiveness), die "gelöste" optimale Lösung (für einen gewissen Wert von "Lucky") mit einem Twist. Da wir genau wissen, wie viele Runden das Spiel dauern wird, sticht dieses Bakterium in der letzten Runde zurück und sorgt so für ein netto-vorteilhaftes Ergebnis gegen jede andere Meise für Tat- und Cooperator-Bakterien (gegen sich selbst endet es mit einer Netto-Null, so als ob es hätte kooperiert). Aufgrund der Verschleppung von 10% ergibt sich ein langfristiger Vorteil.

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"

Bittere Tat

Bitter Tat nutzt alle Kooperationsversuche des Feindes aus, wenn der Feind in Punkten voraus ist. Die meisten Bakterien bieten während der 200 Runden mindestens einmal einen Olivenzweig an, und da Bitter Tat insgesamt zurückliegt, werden diese 5 Punkte in einem verzweifelten Gebot für eine Erholung gemolken.

Ansonsten ist es TIT-FOR-TAT gemäß der üblichen dominanten Strategie. Außerdem ist es ein bisschen mehr ein Trottel als sein Cousin und sticht eine Runde früher zurück und bietet keine Vergebung.

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 wurde entwickelt, indem das Verhalten anderer Bots gegen Tit for Tat und die in diesen Ergebnissen ausgedrückten Muster untersucht wurden. Es wurde jedoch nicht entwickelt, um diesen Strategien explizit entgegenzuwirken: Es handelt sich immer noch um eine Allzweckformel.

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

Extra bitter durch extra frühes Überlaufen.

Antikapitalist

Noch eine einfache. Denn gerade Matches (beginnend mit derselben Punktzahl) verhalten sich ziemlich ähnlich wie TitForTat, aber die Hauptidee ist, das Match zu überleben.

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

Sanfter Überläufer

Meine Idee hier ist es, zu defekten, außer wenn mein Feind normalerweise zusammenarbeitet. Es beginnt jedoch zu kooperieren.

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

NeoAnticapitalist

Eine Verbesserung des Antikapitalisten (oder so denke ich). Ich sehe keinen Grund, in der letzten Runde zusammenzuarbeiten. Ich sehe auch keinen Grund zur Zusammenarbeit, wenn ich mir ziemlich sicher bin, dass mein Gegner dies nicht tun wird.

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"

Reumütiger Aggressor

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"

Dies wurde entwickelt, um mit Defector Schritt zu halten, indem jedes Mal dagegen vorgegangen wird, und um Strategien zu übertreffen, die auf TIT-for-TAT basieren.

Die Grundidee ist, dass wir mit dem Defekt beginnen, aber wenn der Gegner in Runde 1 kooperiert, kooperieren wir zweimal, um einen gegenseitigen Rekriminierungszyklus zu vermeiden und so eine zu große Punktstrafe zu vermeiden. (Wenn der Gegner jedoch später Fehler macht, unterbrechen wir den Zyklus nicht selbst. Wir lassen ihn dies tun und verlieren wahrscheinlich das Spiel.) Am Ende des Spiels wählen wir eine zufällige Zeit In den letzten 5 Runden haben wir den Feind zurückgestochen, wodurch wir einen Fehler mehr als er gemacht haben. Das bedeutet, dass wir am Ende gewinnen, solange wir nicht zu weit hinter den Übertragspunkten zurückbleiben, ohne dabei viel an Übertragsleistung zu verlieren . (Wenn wir den Zeitraum nach dem Zufallsprinzip bestimmen, ist es sehr wahrscheinlich, dass wir mit dem Backstab an erster Stelle stehen. Außerdem kann diese Strategie nicht durch das Ziel "gegengestimmt" werden, den Backstab eine Runde früher zu setzen.)

Grimmiger Auslöser

Einfacher Bot, um zu versuchen, den Wettbewerb auszufüllen

Es wird kooperieren, es sei denn, der Feind weist Mängel auf

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

Nun, anscheinend funktioniert dies nicht, weil das Meta des frühen Defekts nicht stimmt

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"

Die Idee dabei ist, dass man niemals verlieren kann, wenn man betrügt. Der einzige Grund zur Zusammenarbeit ist, wenn man hinterher ist. Es hat auch den allgemeinen Rahmen der anderen T4T-Antworten (ohne Verzeihung, weil ich nicht sicher bin, ob es bei den anderen Konkurrenten hier viel Sinn macht).

Die Wende zum Verrat muss möglicherweise geändert werden, um zu gewinnen, da in einem ausgeglichenen Rennen der T4Ter, der zuerst verrät, gewinnt, aber gegen einen sehr kooperativen Bot werden Sie einige Lebenspunkte verpassen. Ich bin mir nicht sicher, ob der Scheitelpunkt für diesen Hügel der richtige ist, also werde ich nur 140 sein. Es würde mich allerdings nicht wundern, wenn es viel früher wäre.

Wenn dies in einer Petrischale mit einem T4Ter endet, der sich früher verrät, oder einem Überläufer (dh 146 T4T), dann hängt es ganz davon ab, ob der GoT bereits vorne ist (er bleibt vorne) oder ob er sogar / GoT hinten ist In diesem Fall gewinnt der frühe Verräter.

Glücksbringer für 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"

Ich bin mir ziemlich sicher, dass ich irgendwo gelesen habe, dass "tit for tat" die beste Strategie war. Ich habe beschlossen, es anderen Programmen zu ermöglichen, sich selbst zurückzukaufen, um noch mehr Abwechslung zu schaffen. Jetzt mit einem richtigen Zufallsgenerator (gibt es mir einen Vorteil, oder?).

Der Elefant

Der Elefant vergisst nie!

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"

Der Elefant blickt auf die Geschichte des Kampfes und versucht herauszufinden, was der Feind geplant hat. Er schaut sowohl auf seine Bewegungen als auch auf seine Feinde!

Er versucht, die längste gleichzeitige Gruppe zu finden, die dem entspricht, was gerade passiert ist, und nimmt das, was der Feind unmittelbar danach getan hat.

Wenn er es nicht schafft, kooperiert der Elefant einfach, denn Freundschaft ist immer die Antwort.

Wenn er glaubt, dass sein Gegner scheitert, scheitert auch er und möchte seine hart erarbeiteten Punkte nicht verlieren.

Wenn er glaubt, dass sein Gegner kooperieren wird, aber seine weniger als oder genau 6 Punkte führen, dann wird er übergehen, um etwas Fuß zu fassen.

Und schließlich, wenn er glaubt, dass sein Gegner kooperieren wird und er einen starken Vorsprung hat, wird er kooperieren.

54 Titten Für Eine Tat

def fünfzigfourtitsfortatfunc (num, more, fun, me, en):
    Titten = 54
    wenn "d" in en [-tits:] oder num> = (200-tits):
        return "d"
    return "c"

Netter Typ

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"

Versucht, die Leistung des Gegners anhand des Verlaufs vorherzusagen. Wenn zum Beispiel die letzten Züge ( c, Feind d) waren, wird versucht, das letzte Vorkommen der exakt gleichen Züge zu finden.

Hackman [disqualifiziert wie erwartet]

Ok, dieser wird wahrscheinlich vom Wettbewerb ausgeschlossen, aber ich habe wirklich Lust, es auszuprobieren:

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"

Hier stütze ich mich auf das BackstabbingTitForTat, das sich in meinen Simulationen als das Beste erwiesen hat. Außerdem basiert es stark auf der Verwendung eines nicht verwendeten Symbols "#"(aus diesem Grund sage ich, dass dies wahrscheinlich ausgeschlossen wird).

Lassen Sie mich nun die Bedingungen hier erklären:

1. Stellen Sie sicher, dass zwei Hackman zusammenarbeiten, wenn etwas schief gelaufen ist.

2. Wenn ich gegen einen anderen Bot verliere, soll er mindestens so viele Punkte wie möglich verlieren, damit er danach kein großer Feind ist.

3. Verrate eine Runde zuvor und gewinne gegen Backstabbing

Wenn ich "#" anstelle von "d" benutze, bekomme ich 0 Punkte anstelle von -1 und kommuniziere auch mit anderen Hackman, die weniger Punkte haben, sodass er aufhört zu defektieren.

Bizzaro

Ist das genaue Gegenteil von tit für tat. Wenn jemand freundlich zu ihm ist, zeigt er seine Liebe, indem er böse ist, und wenn jemand gemein ist, zeigt er Rache, indem er gut ist. Stark basierend auf tit for tat.

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

6 Titten für eine Tat

def sixtitsforatatfunc (num, more, fun, me, en):
    wenn "d" in en [-6:] oder num> = 194:
        return "d"
    return "c"

Tit for Tat Wettrüsten ist passiert :)

Zehn Titten für eine Tat

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

Fehler früher und auch Fehler, wenn der Gegner in den letzten zehn Runden einen Fehler gemacht hat.

CopyFirst

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

Dies schadet der ersten Runde und macht dann, was der Gegner in der ersten Runde getan hat, bis zur 197. Runde, in der er zurücksticht.

Vierzig Titten für eine Tat

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

Wenn der Gegner in den letzten 40 Runden defekt ist, defekt, sonst kooperieren. Backstab in den letzten 50 Runden.

Drei Titten für eine Tat

Wenn der Gegner in den letzten 3 Runden defekt ist, defekt, ansonsten kooperieren. Backstab in den letzten 5 Runden. Dieses Programm hat Tit for Two Tats die Führung mit einem knappen Vorsprung genommen.

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"

Fünf Titten für eine Tat

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

Wenn Sie nicht herausfinden können, was dieser tut, sind Sie ein Idiot. Auch eine Runde früher backstabs.

Grimasse

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

Jeder andere D

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

Jedes andere C

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

Vorhersehbare Mathematiker:

Junger Mathematiker

Neu in der Härte der Welt

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

Älterer Mathematiker

Erfahrener in diesen Angelegenheiten

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

Ich bezweifle, dass beides gut funktioniert, aber zumindest bieten sie anderen die Möglichkeit, Punkte zu sammeln!

Zufällige Meise Für 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, aber randomisiert. Dies wird keine Preise gewinnen (es sei denn, ich habe wirklich Glück). Jetzt mit Zufallszahlen aus einer richtigen Quelle.

Ausbeuterische Tat

Exploitative Tat versucht folgende Strategien zu spielen:

• Defekt wenn hinten. Nur so können Sie aufholen.

• Kooperieren Sie gegen TIT-for-TAT und ähnliche Strategien. Dies ist der einzige Weg, um langfristig eine gute Punktzahl zu erzielen.

• Defekt gegen immer-Mitarbeiter und andere Trottel.

• 5 Runden zu früh defekt.

Hier ist der Code:

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 Titten für eine Tat

Auf jeden Fall dreißig Jahre (Anzahl, mehr, Spaß, ich, de):
    Titten = 30
    wenn "d" in en [-tits:] oder num> = (200-tits):
        return "d"
    return "c"

aber was wenn ... die nächste antwort war nicht grimmiger auslöser oder so was für tat

Ich präsentiere

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"

Fuchs

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

Defekte, wenn die Rundenzahl größer ist als die Feindpunkte, kooperieren ansonsten.

Der Junge

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"

Arbeitet in der ersten Runde mit, dann geht es um das Gegentor in den letzten fünf Runden und es gibt Defekte, wenn es keine zehn Punkte Vorsprung gibt.

53 Titten für eine Tat

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

Ihr alle wisst was das ist :)

Fünfundzwanzig Titsforatat

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

Ein bisschen Titsforatat

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

Kluger Verräter

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"

Angenommen, es kämpft gegen einen n-tits-for-a-tatBot. Wenn es die Punktzahl hat, die verraten werden muss, und trotzdem gewinnt, lässt es den anderen Bot zuerst zuschlagen (als Tit for Tat spielen) bot. Wenn er viele Punkte hinter seinem Gegner liegt, spielt er nur den Überläufer, um die Punktzahl der ahnungslosen Bots zu senken.

Handschlag

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"

Verwendet das Muster cdccdin den ersten fünf Runden, um herauszufinden, ob es mit sich selbst ist. In diesem Fall wird versucht, seine Punkte zu maximieren, indem der Bot mit mehr Punkten immer fehlerhaft ist, während der andere immer zusammenarbeitet. Wenn es feststellt, dass es einen Feind bekämpft, spielt es den Überläufer.

In meinen Tests finde ich, dass es gut dosiert ist, wenn es einen bedeutenden Teil der Bevölkerung ausmacht. Wenn es keine Chance hat, sich selbst zu bekämpfen, wird es im Grunde genommen zu einem Überläufer.

EDIT: Aus den Scores geht eindeutig hervor, dass es zu viele Bots gibt, damit dies gut funktioniert. Es wird immer noch gewinnen, wenn es nur um die Besten geht ...

Bizzaro-Auslöser

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

Arbeiten Sie immer mit, es sei denn, Ihr Gegner arbeitet jemals mit Ihnen zusammen. In diesem Fall treten Sie einen Defekt auf. Immer.

FakeShake

nutzt Handshake - macht einen Handshake, der nur fehlerhaft ist, während Handshake ihm vertraut. Wenn es sich jedoch selbst trifft, führt es den "echten" Handschlag aus. Wenn es auf einen anderen Bot trifft, spielt es mit einem Verrat am Ende. Das fühlt sich irgendwie gemein an ...

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"

Ein Problem dabei ist, dass es denkt, wenn es auf Handschlag trifft und mehr Punkte hat, dass es selbst spielt. Ich bin ein Neuling in Python und diese Seite (in der Tat ist dies meine erste Antwort), also sag mir Bescheid, wenn ich irgendwelche dummen Fehler gemacht habe!