一位疯狂的科学家刚刚创造出一种新细菌！他决定将其命名为Noblus Gentlemanus，观察其行为后。但是，他的细菌已经用完了食物，并宣战了，因为它们能够收获其他细菌的尸体以获取足够的食物来复制自身。该细菌有许多不同的亚种，在玩他们最喜欢的囚徒困境时有不同的策略。每个不同亚种都有5种细菌。在《囚徒困境》中，两个玩家中的每一个都同时选择缺憾或合作。如果一个玩家选择合作，而另一个选择默认，则默认者获得2分，而合作者则损失3分。如果双方选择合作，双方将获得1分。如果两个玩家都选择默认值，则两个玩家都将失去1分。

作为贵族绅士，这种细菌决定通过玩200轮漫长的囚徒困境游戏来打赢这场战争。每个决斗的失败者都会自杀，从而使胜利者得以自我克隆。如果打成平手，两种细菌都将保持存活，但两者均无法克隆。此外，一场比赛中的所有细菌都会将其点数的10％携带到下一场比赛中。克隆携带克隆它的细菌的各个点。同样，每轮细菌有十分之一的机会突变为另一种亚种，获得0分（如果我收到对此随机性的投诉，可以将其删除）。在细菌打出的决斗数量等于细菌的亚种数量乘以十之后，疯狂的科学家不小心掉落了细菌所在的培养皿，所有细菌都获得了新的食物来源，结束了决斗。这与普通的迭代囚徒困境竞赛不同，因为它涉及带有结转分数的1v1决斗，而不是简单地尝试总体上获得最高分数。这在给定策略的有效性方面有很大的不同。

每个细菌将在回合开始时以以下格式输入：（回合编号，当前点，敌人点，您之前的举动[以字符串形式，以字符“ c”表示合作，以字符“ d”表示缺陷） ]，敌人先前的举动[格式相同]）。

这里将输入四个样本策略。我实际上认为Defector可能会获胜，尽管它非常简单。

针锋相对

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

随机选择

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

合作者

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

偏转器

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

所有提交都必须采用Python 2.7函数的形式，名称是提交的名称，不带空格，并func在末尾。如果有人想用其他语言提交答案，请用伪代码输入答案，以便我有时间后在对您的答案进行编辑时转换为Python，或者给我有关将语言与控制器交互的说明，可在6月4日之前为所有提交设置以下内容。

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:

此竞赛现已结束

如果您想添加一个答案，我将看看是否可以在原始参赛者之一的下方添加一个挑战后记分板。我将在测试程序完成后（大概再2-3天）添加一个。

最终得分！！！！

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

因此，看来完美绅士是胜利者。恭喜Draco18，他绝对值得其绿色复选标记。

完美绅士

我对该机器人没有很好的描述。我偶然发现了一些潜在的优化方案，对其进行了测试，进行了微调，最后发现了一种彻底破坏竞争的细菌。相反，我对代码本身进行了注释，以解释其功能。

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]

任意选择了几个值，并选择了经过测试的替代方案，此时，此处的值接近最佳。在目前敌对派系蔓延的情况下，完美绅士在大约90％的时间（正负3个百分点）内实现了完全的统治地位（占细菌总数的100％）。

我还没有在数学家中加入数学测验，但是这两项仅应用于补充现有策略，而不能极大地改变结果。

它确实通过支撑Defector来管理很大一部分控制，但是规则允许这样做（示例策略是针对目标的公平游戏）。它的副作用也支撑着权力的游戏，但那是无意因为这两个基础上，我选择的标准是无法区分的。然后，这些“偏转器类型”在第2轮中拥有点优势，并因此淘汰了几个麻烦的邻居（N-T4T类型），当他们改写“完美绅士”时，他们已经扩大了点优势，并很快被消耗掉了。

在第一轮中，所有完美绅士最终有机会与Defector类型配对，并最终自杀。在这种情况下，n-T4t类型之一可实现总控制（196个单元中的196个）。很少有其他类型之一（权力的游戏，男孩，鬼脸，失败者……）设法完全灭绝并获得一分或两分。

当前模拟（仍在进行200场比赛）。评分为0的所有条目均已删除。就像《权力的游戏》和54-T4T在PG被淘汰之后进行了一轮比赛（他们之间获得195分）。

Game: 90

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

##Simulation Terminated: Adding new bots

背刺针刺（宽恕）

这基本上是达克的幸运山雀（又名宽恕的达克山雀），它是“解决”的最佳解决方案（对于“幸运”的某些值），带有一些扭曲。我们知道比赛将持续多少回合，这种细菌会在最后一轮出现刺伤，从而确保针对Tat和Cooperator细菌的任何其他Tit都能获得净收益（相对于它本身，其净结尾为零，就像合作）。由于有10％的残留，因此具有长期优势。

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"

苦塔

苦涩达人利用任何敌方领先时，敌方发动尝试都。大多数细菌在200发子弹中至少会提供一个橄榄枝，而Bitter Tat总体上落后了，它会挤迫这5点，以求恢复。

否则，它会按照通常的主导策略进行调整。而且，它比表亲和背刺更像是一个混蛋，而且早在前一回合就没有刺痛，也没有宽恕。

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是通过查看其他针对Tit for 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"

通过尽早叛逃而变得更加痛苦。

反资本主义

另一个简单的。对于均匀比赛（以相同分数开始），其行为与TitForTat十分相似，但主要思想是设法在比赛中生存下来。

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

温柔的偏转器

我的想法是叛逃，除非我的敌人通常在合作。虽然，它开始合作。

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

新反资本主义

反资本主义的进步（或者我认为）。我认为没有理由在最后一轮进行合作。当我非常确定对手不会的时候，我也没有理由合作。

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"

悔的侵略者

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"

它旨在通过每次都背叛Defector来“保持”，并击败基于针锋相对的策略。

基本思想是，我们从投篮开始，但是如果对手在第1回合配合，则我们将进行两次合作以避免相互重新判罚的循环，从而避免了太大的罚分。（但是，如果以后对手出现缺陷，我们不会自己打破循环；我们会让他们这样做，并有可能因此而输掉游戏。）然后，在游戏结束时，我们随机选择一个时间在最后五个回合内以反击刺伤敌人，使我们的叛逃比他们还多，这意味着只要我们在遗留点上的差距不大，我们最终就会获胜，而在此过程中不会牺牲太多遗留物。（将时间段随机化意味着我们很可能首先使用背刺，也无法通过旨在提前背刺一次来“反对”此策略。）

冷酷触发

简单的机器人，尝试填写竞赛

除非敌人叛变，否则它将合作，在这种情况下，它将无情地叛逃

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

好吧，由于早期背叛的ntitsfortat元，这似乎不起作用

权力的游戏

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"

这里的想法是，您永远不会因背叛而迷失方向，所以合作的唯一理由就是落后。它还具有其他T4T答案的一般框架（无需任何宽恕，因为我不确定此处的其他竞争者是否有很多意义）。

可能需要改变背叛的转向才能赢得胜利，因为在均匀比赛中，首先背叛的T4Ter会获胜，但是在一个非常合作的机器人的对抗下，您会错过一些终生得分。我不确定这个山峰的顶点，所以我只想去140。不过，如果它早得多的话，我也不会感到惊讶。

如果这最终与先前背叛的T4Ter或叛逃者（即146 T4T）一起出现在皮氏培养皿中，那么这完全取决于GoT是否已经领先（它将保持领先）还是他们甚至/ GOT落后，在这种情况下，早期的背叛者将获胜。

幸运山雀达

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"

我很确定我读过某个地方说“针锋相对”是最好的策略。我决定让其他程序有可能赎回自己，只是增加一些种类。现在有了一个适当的随机数生成器（它给我带来了好处吗？）。

大象

大象永远不会忘记！

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"

大象查看战斗的历史，并试图弄清敌人的计划。他看着自己的举动和敌人！

他试图找到与发生的事情相匹配的最长的并发小组，并在此之后采取敌人的行动。

如果他不能解决问题，大象会合作，因为友谊永远是答案。

如果他认为对手会背叛，他也将背叛，不想失去辛苦赚来的积分。

如果他认为他的对手会合作，但他的领先优势不足或恰好是6分，那么他就会背叛，获得立足点。

最后，如果他认为他的对手会合作，并且他有很强的领先优势，那么他会合作。

54针锋相对

def fiftyfourtitsfortatfunc（num，more，fun，me，en）：
    山雀= 54
    如果en [-tits：]中的“ d”或num> =（200-tits）：
        返回“ d”
    返回“ c”

好人

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"

尝试通过查看历史预测对手的输出。例如，如果最后一个动作是（c，敌人d），它将尝试查找完全相同的动作的最后一次出现。

哈克曼 [取消资格符合预期]

好的，这可能会被排除在比赛之外，但是我真的很想尝试一下：

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"

在这里，我以BackstabbingTitForTat作为基础，事实证明这是我的模拟中最好的。此外，它很大程度上取决于使用未使用的符号"#"（这就是为什么我说它可能会被排除的原因）。

现在让我在这里解释条件：

第一个：如果出现问题，请确保两个Hackman合作。

第二：如果我要输给一个不同的机器人，至少要让他失去尽可能多的积分，所以那以后并不是一个大敌人。

第三名：背叛前一回合，所以胜利vs后刺

使用“＃”而不是“ d”使我得到0分而不是-1，并且还与其他拥有较少分的Hackman进行了交流，因此他停止了叛逃。

比扎罗

针锋相对吗？当某人对他友善时，他通过邪恶来表现出他的爱；当某人对他友善时，他通过表现出良好的报仇感。主要基于针锋相对的针锋相对。

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

6针

def sixtitsforatatfunc（num，more，fun，me，en）：
    如果en [-6：]中的“ d”或num> = 194：
        返回“ d”
    返回“ c”

为达军备竞赛的山雀正在发生:)

一针十针

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

较早瑕疵，并且如果对手在最近十个回合中瑕疵，则也会瑕疵。

CopyFirst

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

这会使第一轮出现问题，然后对手在第一轮中所做的一切都会做，直到第197轮后退。

四十奶

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

如果对手在最后40圈内投篮失败，请投篮，否则请配合。最近50转的背刺。

一针三针

如果对手在最后3个回合中有失误，那就变位，否则请配合。最后5回合的背刺。该程序已在很小的程度上窃取了“两点针锋相对”的线索。

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"

一针五雀

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

如果您不知道这是做什么的，那么您就是白痴。还背刺一轮。

鬼脸

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

每隔D

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

每隔C

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

可预测的数学家：

青年数学家

新世界的严酷

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

老数学家

在这些事情上更有经验

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

我怀疑这两种方法都不会做得好，但是至少它们会为其他人增加积分的方法！

随机山雀

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"

针锋相对，但随机。这不会赢得任何奖金（除非我真的很幸运）。现在有了从适当来源生成的随机数。

剥削性

剥削性达尝试发挥以下策略：

• 落后时有缺陷。这是追赶的唯一途径。

• 合作对抗针锋相对和类似策略。这是获得良好长期分数的唯一方法。

• 对始终合作者和其他伙伴的缺陷。

• 提前缺陷5发。

这是代码：

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针

def fiftytitsfortatfunc（num，more，fun，me，en）：
    山雀= 30
    如果en [-tits：]中的“ d”或num> =（200-tits）：
        返回“ d”
    返回“ c”

但是，如果...下一个答案不是严峻的触发条件或不合时宜的做法

有请

安蒂

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"

狐狸

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

如果回合数大于敌人的分数，则为缺陷，否则进行协作。

男孩

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"

合作第一回合，然后在最后五个回合中发挥作用，但最后刺伤，如果领先不到十分则退步。

53一针山雀

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

你们都知道这是什么:)

二十点

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

金达山雀

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

谨慎的背叛者

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"

假设它正在与n-tits-for-a-tat机器人战斗。如果它的分数将被出卖并仍然获胜，它将让另一个机器人首先击中它（以针锋相对的方式发挥作用。）如果它只有在首先出卖时才能获胜，它将在第130轮出卖，远远早于当前机器人。如果对手落后许多分，它只会扮演叛逃者，以降低毫无戒心的机器人得分。

握手

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"

cdccd在前五个回合中使用该模式，以查明其是否与自身相符。如果是这样，它将尝试通过让拥有更多分数的机器人始终处于缺陷状态，而其他机器人始终与之协作来最大化自己的分数。如果发现自己正在与敌人作战，它将扮演叛逃者。

在我的测试中，我发现它占了人口的很大比例。当它没有机会与自己战斗时，它将基本上减少为叛逃者。

编辑：显然，从分数来看，他们对许多机器人来说都很有效。如果只与前几名战斗，它仍然会赢。

Bizzaro扳机

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

始终保持合作，除非您的对手曾经与您合作，在这种情况下您会背叛。总是。

假摇

利用握手的优势-进行握手，然后在握手信任它时仅出现缺陷。但是，当遇到自己时，它会进行“真正的”握手。如果遇到其他机器人，它将以针锋相对，最后背叛。感觉有点意思...

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"

这样做的一个问题是，如果它遇到握手并且有更多积分，它会认为自己在玩游戏。我是python和该站点的新手（实际上，这是我的第一个答案），因此请务必告诉我是否犯了任何愚蠢的错误！