미친 과학자가 새로운 종류의 박테리아를 만들었습니다! 그는 이름을 Noblus Gentlemanus 로 결정했습니다.행동을 관찰 한 후. 그러나 그의 박테리아는 음식이 부족하여 다른 박테리아의 시체를 수확하여 충분한 양의 음식을 만들어 자신의 사본을 만들 수있게함으로써 전쟁을 선포했습니다. 이 박테리아에는 여러 가지 아종이 있으며, 이들은 가장 좋아하는 게임 인 Prisoner 's Dilemma를 플레이하는 데 다른 전략을 가지고 있습니다. 각기 다른 아종으로부터 5 개의 박테리아가 있습니다. 죄수의 딜레마에서 두 선수 각각은 동시에 결함이나 협력을 선택합니다. 한 플레이어가 협력을 선택하고 다른 플레이어가 기본을 선택하면, 기본 플레이어는 2 점을 얻으며 협력자는 3 점을 잃습니다. 두 선수가 협력을 선택하면 두 선수 모두 1 점을 얻습니다. 두 선수 모두 기본을 선택하면 두 선수 모두 1 점을 잃습니다.

귀족 여러분, 박테리아는 200 회 이상 반복 된 죄수의 딜레마 게임을함으로써이 전쟁에 맞서기로 결정했습니다. 각 결투의 패자는 자살하여 승리자가 스스로 복제 할 수 있습니다. 동점 인 경우, 두 박테리아 모두 살아남을 수 있지만, 둘 다 스스로 복제 할 수는 없습니다. 또한, 경기에서 발생하는 모든 박테리아는 다음 경기에서 점수의 10 % 이상을 차지합니다. 클론은 자신이 복제 한 박테리아의 지점을 차지합니다. 또한, 한 번의 박테리아가 한 박테리아가 다른 아종으로 변이 할 확률이 0이며, 보너스 포인트는 0입니다 (이의 무작위성에 대한 불만이 접수되면 제거 할 수 있습니다). 박테리아가 10 번의 박테리아 아종의 수와 동일한 수의 결투를 연주 한 후, 미친 과학자는 실수로 박테리아가 존재하는 페트리 접시를 떨어 뜨립니다. 그리고 모든 박테리아는 새로운 음식 공급원을 얻어 결투를 끝냅니다. 이것은 단순히 전체적으로 가장 많은 점수를 얻는 것이 아니라 이월 포인트가 포함 된 1 대 1 결투를 포함하기 때문에 일반적인 반복 죄수의 딜레마 대회와 다릅니다. 이것은 주어진 전략이 얼마나 효과적인 지에 큰 차이를 만듭니다.

각 박테리아는 차례가 시작될 때 다음과 같은 형식으로 입력을받습니다. ], 이전의 적들은 [같은 형식으로] 움직입니다.

다음은 입력 할 네 가지 샘플 전략입니다. 나는 매우 간단하지만 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

따라서 Perfect Gentleman이 승자 인 것으로 보입니다. 초록색 확인 표시가 필요한 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 유형으로 몇 가지 번거로운 이웃을 제거하고 Perfect Gentleman과 대면 할 때 포인트 우위를 점하고 빠르게 소비됩니다.

첫 번째 라운드에서 모든 퍼펙트 젠틀맨이 디렉터 유형과 짝을 이루고 대량 자살을하게 될 확률은 약 5 %입니다. 이 경우, n-T4t 유형 중 하나는 전체 지배 (196 개 중 196 개 셀)를 달성합니다. 드물게 다른 유형 중 하나 (Game of Thrones, Boy, Grimace, Sore Loser ...)가 완전히 멸종하지 않고 점수를 얻지 못합니다.

현재 시뮬레이션 (여전히 총 ​​200 개 게임 진행 중). 점수가 0 인 모든 항목이 제거되었습니다. PG가 제거 된 후 Game of Thrones와 54-T4T가 라운드를 나눕니다 (그들 사이에 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 for Lucky Tit (일명 용서 Tat for Tat)으로, "해결 된"최적의 솔루션 (일부 "lucky"값)이며 꼬임이 있습니다. 우리 는 게임이 얼마나 많은 라운드 를 지속 할 수 있는지 알고 있듯이 ,이 박테리아는 최종 라운드에서 역전하여 다른 Tit for Tat 및 Cooperator 박테리아에 대해 순 유익한 결과를 보장합니다. 협력). 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에 대해 매번 결함을 제거하여 Defector를 "유지"하고 tit-for-tat 기반 전략을이기도록 설계되었습니다.

기본 아이디어는 우리가 결함으로 시작한다는 것입니다. 그러나 상대방이 1 턴을 협력했다면 상호 재평가주기를 피하기 위해 두 번 협력하여 너무 큰 포인트 페널티를 피합니다. (하지만 나중에 상대 결함이 발생하면 우리는 스스로 사이클을 깨뜨리지 않습니다. 결과적으로 게임을 잃게되고 결과적으로 게임을 잃을 수도 있습니다.) 게임이 끝나면 무작위 시간을 선택합니다 마지막 5 턴 안에 적을 백스탭하여 적들보다 하나 더 많은 탈락을 일으켜서 이월 지점에서 너무 멀리 떨어지지 않는 한 우리는 이월 과정에서 많은 이월을 희생하지 않고 승리를 거둘 수 있습니다. . (기간을 무작위 화한다는 것은 우리가 백스탭을 처음 접할 가능성이 높음을 의미하며,이 전략은 한 번 더 일찍 백스탭을 목표로하여 "조정될 수 없음"을 의미합니다.

잔인한 방아쇠

경쟁을 시도하고 채우는 단순한 봇

적의 결함이 아닌 한, 용서없이 결함이있는 경우에는 협조합니다

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"

나는 tat의 tit이 최고의 전략이라는 것을 어딘가에서 읽었다 고 확신한다. 나는 다른 프로그램이 단지 다양성을 추가하기 위해 스스로를 구속 할 수 있도록 결정했습니다. 이제 적절한 난수 생성기를 사용하면 이점이 있습니다.

코끼리

코끼리는 결코 잊지 않습니다!

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 가슴

데프 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, enemy 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을 기본으로 사용하고 있습니다. 또한 사용되지 않은 기호를 사용하는 데 크게 의존합니다 "#"(따라서 아마도 배제 될 것이라고 생각합니다).

이제 여기에 조건을 설명하겠습니다.

1 차 : 무언가 잘못되었을 경우 2 명의 Hackman이 협조하도록하십시오.

두 번째 : 다른 봇에 대해지게된다면 최소한 그를 최대한 많이 잃게되므로 나중에 큰 적은 아닙니다.

세 번째 : 한 턴 전에 배신하십시오.

"d"대신 "#"을 사용하면 -1 대신 0 점을 얻었으며 점수가 적은 다른 Hackman과 통신하므로 결함을 중지합니다.

비자로

tat에 대한 tit의 정반대입니다. 누군가가 그에게 친절하면 악으로 자신의 사랑을 나타내며, 누군가가 의미가 있으면 선으로 복수를 나타냅니다. tat에 대한 tit에 크게 기반합니다.

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

문신에 대한 6 가슴

데프 sixtitsforatatfunc (num, more, fun, me, en) :
    en [-6 :]에서 "d"또는 num> = 194 인 경우 :
        "d"를 반환
    "c"를 반환

Tat 무기 경주를위한 젖꼭지가 일어나고 있습니다 :)

문신에 대한 10 가슴

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

앞서 결함이 있으며, 마지막 10 턴 동안 상대가 결함이있는 경우 결함도 있습니다.

CopyFirst

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

이것은 1 라운드에 결함을 가한 후 197 라운드까지 백스탭이 될 때까지 상대방이 1 라운드를 한 모든 일을한다.

문신에 대한 40 가슴

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

상대가 지난 40 턴에 결함이 있다면 결함, 그렇지 않으면 협력한다. 지난 50 턴의 백스탭.

문신에 대한 세 가슴

상대가 지난 3 턴에 결함이 있다면 결함, 그렇지 않으면 협력한다. 마지막 5 턴의 백스탭. 이 프로그램은 Tit for Two Tats의 우위를 좁혔습니다.

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"

이것이 무엇을하는지 알 수 없다면, 당신은 바보입니다. 또한 1 라운드 이전에 백스탭을합니다.

그리 메스

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"

Tat For Tat이지만 무작위입니다. 이것은 내가 운이 좋지 않은 한, 어떤 상도 얻지 못할 것입니다. 이제 적절한 소스에서 난수가 생성되었습니다.

착취 문신

Exploitative Tat는 다음 전략을 시도합니다.

• 뒤에서 결함. 따라 잡는 유일한 방법입니다.

• tit-for-tat 및 유사한 전략에 대해 협조하십시오. 좋은 장기 점수를 얻는 유일한 방법입니다.

• 상시 협력자 및 기타 침팬지에 대한 결함.

• 결함 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 thirtytitsfortatfunc (num, more, fun, me, en) :
    가슴 = 30
    en [-tits :]에서 "d"또는 num> = (200-tits) 인 경우 :
        "d"를 반환
    "c"를 반환

그러나 만약에 ... 다음 답변이 잔인한 방아쇠 또는 tat에 대한 것이 아니었다면

나는 선물한다

앤티

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"

1 라운드를 협력 한 후, 마지막 5 라운드에 대해서는 tat에 대해서는 역행을하고 백스탭은 10 점을 넘지 않으면 결함이 있습니다.

tat 가슴 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봇 과 싸우고 있다고 가정합니다 . 배신 할 점수가 있고 여전히이기는 경우, 다른 봇이 먼저 때리게합니다 (Tat에 대한 tit로 재생). 처음 배신 할 때만 이길 수 있다면 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처음 5 개의 라운드 에서 패턴 을 사용하여 자체 패턴 인지 확인합니다. 그렇다면 더 많은 포인트를 가진 봇이 항상 결함을 가지고 다른 하나는 항상 협력하여 포인트를 최대화하려고 시도합니다. 그것이 적과 싸우는 것을 발견하면 탈북자 역할을한다.

내 테스트에서 인구의 상당 부분을 차지하면 복용량을 잘 알았습니다. 자체적으로 싸울 기회가 없으면 기본적으로 탈북자로 축소됩니다.

편집 : 분명히 점수에서, 그들은 잘 작동하기 위해 많은 봇에 있습니다. 상위 몇 명과 싸워도 여전히 승리 할 것입니다 ...

비사로 트리거

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

상대방이 당신과 협력하지 않는 한 항상 협조하십시오. 항상.

페이크 쉐이크

핸드 셰이크를 사용하는 반면 핸드 셰이크는 핸드 셰이크를 신뢰하는 반면 결함 만 수행합니다. 그러나 스스로 만나면 '진정한'악수입니다. 다른 봇을 만나면 끝에 배신과 함께 tat의 가슴을 재생합니다. 이것은 다소 의미가 있습니다 ...

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"

이것의 한 가지 문제는 악수를 만났고 더 많은 포인트가 있으면 재생 자체를 생각한다는 것입니다. 나는 파이썬 초보자 이며이 사이트 (사실이 첫 번째 대답입니다) 어리석은 실수를했는지 알려주십시오!