Một nhà khoa học điên vừa tạo ra một loài vi khuẩn mới! Ông đã quyết định đặt tên cho nó là Noblus Genteldus, sau khi quan sát hành vi của nó. Tuy nhiên, vi khuẩn của anh đã hết thức ăn và đã tuyên chiến, vì họ có thể thu hoạch xác chết của vi khuẩn khác để có đủ thức ăn để tạo ra bản sao của chính chúng. Có một số phân loài khác nhau của vi khuẩn này, những người có chiến lược khác nhau trong việc chơi Prisoner Dilemma, trò chơi yêu thích của họ. Có năm vi khuẩn từ mỗi phân loài khác nhau. Trong Thế lưỡng nan của tù nhân, mỗi người trong số hai người chơi đồng thời chọn khuyết điểm hoặc hợp tác. Nếu một người chơi chọn hợp tác và người còn lại chọn mặc định, người mặc định được 2 điểm và người hợp tác mất 3 điểm. Nếu cả hai người chơi chọn hợp tác, cả hai người chơi đều được 1 điểm. Nếu cả hai người chơi chọn mặc định, cả hai người chơi đều mất 1 điểm.

Trở thành quý ông quý tộc, các vi khuẩn đã quyết định chiến đấu với cuộc chiến này bằng cách chơi 200 trò chơi dài vòng lưỡng nan của tù nhân lặp đi lặp lại. Người thua cuộc trong mỗi cuộc đấu tay đôi sẽ tự sát, cho phép kẻ chiến thắng tự nhân bản. Trong trường hợp hòa, cả hai vi khuẩn sẽ vẫn sống, nhưng cả hai sẽ không thể tự nhân bản. Ngoài ra, tất cả các vi khuẩn từ một trận đấu mang hơn 10% số điểm của chúng cho trận đấu tiếp theo. Một bản sao mang trên các điểm của vi khuẩn mà nó được nhân bản. Ngoài ra, có một trong mười cơ hội mỗi lượt một vi khuẩn sẽ biến đổi thành một phân loài khác, với 0 điểm thưởng (nếu tôi nhận được khiếu nại về tính ngẫu nhiên của điều này, tôi có thể loại bỏ nó). Sau khi vi khuẩn đã chơi một số cuộc đấu tay đôi với số lượng phân loài vi khuẩn gấp mười lần, nhà khoa học điên đã vô tình làm rơi đĩa petri mà vi khuẩn cư trú. và tất cả các vi khuẩn có được nguồn thức ăn mới, kết thúc cuộc đấu tay đôi của chúng. Điều này khác với một cuộc thi tiến thoái lưỡng nan của một tù nhân bình thường, vì nó liên quan đến các cuộc đấu tay đôi 1v1 với các điểm chuyển giao, thay vì chỉ đơn giản là cố gắng để có được nhiều điểm nhất. Điều này tạo ra sự khác biệt lớn trong hiệu quả của một chiến lược nhất định.

Mỗi vi khuẩn sẽ nhận được đầu vào ở đầu lượt của nó theo định dạng: (số lần lượt, điểm hiện tại, điểm kẻ thù, di chuyển trước đó của bạn [trong một chuỗi, sử dụng ký tự "c" để hợp tác và ký tự "d" cho lỗi ], kẻ thù di chuyển trước đó [trong cùng định dạng]).

Dưới đây là bốn chiến lược mẫu sẽ được nhập. Tôi thực sự nghĩ rằng Defector có thể thắng, mặc dù nó cực kỳ đơn giản.

Tít cho tất

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

Chọn ngẫu nhiên

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

Hợp tác xã

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

Người đào ngũ

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

Tất cả các bài nộp phải ở dạng hàm Python 2.7, với tên là tên của bài nộp không có khoảng trắng, funcở cuối. Nếu ai đó muốn gửi câu trả lời bằng một ngôn ngữ khác, vui lòng nhập nó bằng mã giả, để tôi chuyển đổi sang Python trong bản chỉnh sửa thành câu trả lời của bạn khi tôi có thời gian hoặc cho tôi hướng dẫn về việc giao tiếp ngôn ngữ của bạn với bộ điều khiển của tôi được tìm thấy dưới đây được thiết lập cho tất cả các đệ trình kể từ ngày 4 tháng Sáu.

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:

Cuộc thi này đã kết thúc

Nếu bạn muốn thêm câu trả lời, tôi sẽ xem liệu tôi có thể đi xung quanh để thêm bảng điểm sau thử thách dưới bảng điểm cho các thí sinh ban đầu không. Tôi sẽ thêm cái đó ngay sau khi chương trình thử nghiệm kết thúc (có thể là 2-3 ngày nữa).

QUẦN ÁO CUỐI CÙNG !!!!!

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

Vì vậy, có vẻ như Quý ông hoàn hảo là người chiến thắng. Xin chúc mừng Draco18, người chắc chắn xứng đáng với dấu kiểm màu xanh lá cây của anh ấy.

Quý ông hoàn hảo

Tôi không có một mô tả hay cho bot này. Tôi tình cờ tìm thấy một vài tối ưu hóa tiềm năng, thử nghiệm chúng, tinh chỉnh và kết thúc với một loại vi khuẩn hoàn toàn phá hủy sự cạnh tranh. Thay vào đó, tôi đã nhận xét chính mã để giải thích những gì nó làm.

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]

Một số giá trị được chọn tùy ý với các lựa chọn thay thế được thử nghiệm và các giá trị ở đây gần như tối ưu tại thời điểm này. Chống lại sự lây lan của các phe phái đối lập hiện nay, Quý ông hoàn hảo đạt được sự thống trị hoàn toàn (100% dân số vi khuẩn) khoảng 90% thời gian (cộng hoặc trừ 3 điểm phần trăm).

Tôi chưa thêm vào các nhà toán học vào các bài kiểm tra của mình, tuy nhiên hai điều đó chỉ nên phục vụ cho các chiến lược hiện có và không làm thay đổi kết quả rất nhiều.

Nó quản lý một phần tốt quyền kiểm soát của mình thông qua việc nâng cấp Defector, nhưng điều đó được cho phép theo các quy tắc (các chiến lược ví dụ là trò chơi công bằng để nhắm mục tiêu). Nó cũng có tác dụng phụ là cũng ủng hộ Game of Thrones, nhưng điều đó là vô tình vì cả hai không thể phân biệt được dựa trên các tiêu chí tôi đã chọn. Những "kẻ đào ngũ" sau đó có lợi thế về điểm ở vòng 2 và kết quả là có một vài người hàng xóm rắc rối (loại N-T4T) và khi họ giới thiệu Người đàn ông hoàn hảo, họ đã tận dụng lợi thế điểm của mình và nhanh chóng bị tiêu hao.

Có khoảng 5% cơ hội rằng tất cả các quý ông hoàn hảo kết hợp với các loại Defector trong vòng đầu tiên và cuối cùng tự tử hàng loạt. Trong trường hợp đó, một trong các loại n-T4t đạt được sự thống trị hoàn toàn (196 ô của 196). Rất hiếm khi một trong những loại khác (Game of Thrones, Boy, Grimace, Sore Loser ...) quản lý để không bị tuyệt chủng hoàn toàn và ghi được một hoặc hai điểm.

Mô phỏng hiện tại (vẫn đang trong tiến trình tới 200 trò chơi tổng số). Tất cả các mục ghi 0 bị xóa. Có vẻ như Game of Thrones và 54-T4T đã chia một vòng (195 điểm giữa họ) sau khi PG bị loại.

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 cho Tat (với sự tha thứ)

Về cơ bản, đây là Lucky Tit cho Tat (còn gọi là Tit cho Tat với sự tha thứ) là giải pháp tối ưu "đã giải quyết" (đối với một số giá trị của "may mắn"), với một bước ngoặt. Như chúng ta đã biết chính xác trò chơi sẽ kéo dài bao nhiêu vòng , vi khuẩn này đã tấn công vào vòng cuối cùng, do đó đảm bảo kết quả có lợi cho bất kỳ vi khuẩn Tit nào khác đối với vi khuẩn Tat và Cooperator (đối với chính nó kết thúc bằng số 0, giống như khi nó có hợp tác). Do tỷ lệ chuyển nhượng 10%, điều này mang lại lợi thế lâu dài.

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"

Đắng tất

Bitter Tat tận dụng mọi nỗ lực hợp tác do kẻ thù đưa ra khi kẻ địch đi trước về điểm. Hầu hết các vi khuẩn cung cấp một nhánh ô liu ít nhất một lần trong suốt 200 vòng, và vì Bitter Tat đứng sau tổng thể, nó sẽ vắt sữa 5 điểm trong một nỗ lực tuyệt vọng để phục hồi.

Mặt khác, nó ăn miếng trả miếng theo chiến lược chi phối thông thường. Ngoài ra, đó là một chút giật hơn so với anh em họ của nó và chống lại một vòng trước đó và không tha thứ.

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 được thiết kế thông qua việc xem xét hành vi của các bot khác đối với Tit cho Tat và các mô hình thể hiện trong các kết quả đó, nhưng không được thiết kế để chống lại các chiến lược đó một cách rõ ràng: nó vẫn là một công thức mục đích chung.

Thêm đắng

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"

Thêm cay đắng bằng cách đào thoát thêm sớm.

Thuốc chống loạn thần

Một số đơn giản. Đối với các trận đấu chẵn (bắt đầu ở cùng số điểm) hoạt động khá giống TitForTat, nhưng ý tưởng chính là cố gắng sống sót trong trận đấu.

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

Người đào ngũ hiền lành

Ý tưởng của tôi ở đây là đào thoát trừ khi kẻ thù của tôi thường hợp tác. Mặc dù, nó bắt đầu hợp tác.

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

NeoAnticapitalist

Một sự cải tiến của Anticapitalist (hoặc tôi nghĩ vậy). Tôi thấy không có lý do để hợp tác vào lượt cuối cùng. Tôi cũng thấy không có lý do gì để hợp tác khi tôi chắc chắn rằng đối thủ của mình sẽ không.

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"

Kẻ xâm lược hối hận

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"

Điều này được thiết kế để "theo kịp" với Defector, bằng cách đào thoát mọi lúc chống lại nó, và cũng để đánh bại các chiến lược dựa trên tiêu chuẩn.

Ý tưởng cơ bản là chúng tôi bắt đầu bằng cách đào thoát, nhưng nếu đối thủ hợp tác rẽ 1, thì chúng tôi hợp tác hai lần để tránh chu kỳ khiển trách lẫn nhau, do đó tránh bị phạt quá lớn. (Tuy nhiên, nếu sau đó, đối thủ khiếm khuyết, chúng ta sẽ không tự phá vỡ chu kỳ; chúng ta sẽ khiến họ làm điều đó và có khả năng thua trò chơi.) Sau đó, vào cuối trò chơi, chúng ta chọn một thời gian ngẫu nhiên trong vòng 5 lượt cuối cùng để chống lại kẻ thù, cho chúng ta thêm một lần đào tẩu so với chúng và do đó, miễn là chúng ta không đi quá xa về điểm tiếp quản, chúng ta sẽ chiến thắng, mà không phải hy sinh nhiều về quá trình chuyển giao trong quá trình . (Ngẫu nhiên khoảng thời gian có nghĩa là chúng tôi rất có thể tham gia đầu tiên với backstab, cũng là chiến lược này không thể được "điều chỉnh" bằng cách nhắm mục tiêu chống lại nó một lượt trước đó.)

Kích hoạt Grim

Bot đơn giản, để thử và điền vào cuộc thi

Nó sẽ hợp tác, trừ khi kẻ thù khiếm khuyết, trong trường hợp đó, nó không thể tha thứ

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

tốt, có vẻ như điều này không hoạt động vì meta ntitsfortat sớm đào thoát

Trò chơi vương quyền

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"

Ý tưởng ở đây là bạn không bao giờ có thể thua bằng cách phản bội, vì vậy lý do duy nhất để hợp tác là nếu bạn đứng sau. Nó cũng có khuôn khổ chung cho các câu trả lời T4T khác (không có bất kỳ sự tha thứ nào, bởi vì tôi không chắc có nhiều điểm với các ứng cử viên khác ở đây không).

Lần lượt phản bội có thể cần phải thay đổi để giành chiến thắng, vì trong một cuộc đua chẵn, T4Ter phản bội trước sẽ chiến thắng, nhưng đối với một bot rất hợp tác, bạn sẽ bỏ lỡ một số điểm trọn đời. Tôi không chắc chắn đỉnh cao phù hợp cho ngọn đồi này, vì vậy tôi chỉ đi cho 140. Mặc dù vậy, tôi sẽ không ngạc nhiên nếu nó sớm hơn nhiều.

Nếu điều này kết thúc trong một đĩa petri với một T4Ter phản bội trước đó hoặc một kẻ đào ngũ (tức là 146 T4T), thì điều đó hoàn toàn phụ thuộc vào việc GoT đã đi trước (nó sẽ ở phía trước) hoặc nếu họ thậm chí / GoT đứng sau , trong trường hợp người phản bội sớm sẽ giành chiến thắng.

Lucky Tit cho tất cả

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"

Tôi khá chắc chắn rằng tôi đã đọc ở đâu đó rằng ăn miếng trả miếng là chiến lược tốt nhất. Tôi quyết định biến nó thành một khả năng để các chương trình khác tự chuộc lại chỉ để thêm một số loại. Bây giờ với một trình tạo số ngẫu nhiên thích hợp (nó mang lại cho tôi một lợi thế phải không?).

Con voi

Con voi không bao giờ quên!

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"

Con voi nhìn vào lịch sử của cuộc chiến, và cố gắng tìm ra những gì kẻ thù đã lên kế hoạch. Anh ta nhìn vào cả di chuyển và kẻ thù của mình!

Anh ta cố gắng tìm nhóm đồng thời dài nhất phù hợp với những gì vừa xảy ra, và lấy những gì kẻ thù đã làm ngay sau đó.

Nếu anh ta không thể giải quyết được, Voi sẽ hợp tác, vì tình bạn luôn là câu trả lời.

Nếu anh ta nghĩ rằng đối thủ của mình sẽ đào tẩu, anh ta cũng sẽ đào tẩu, không muốn mất điểm khó kiếm được.

Nếu anh ta nghĩ rằng đối thủ của mình sẽ hợp tác, nhưng anh ta dẫn ít hơn hoặc chính xác 6 điểm, thì anh ta sẽ đào tẩu, để có được chỗ đứng.

Và cuối cùng, nếu anh ta nghĩ rằng đối thủ của mình sẽ hợp tác, và anh ta có một vị trí dẫn đầu mạnh mẽ, anh ta sẽ hợp tác.

54 Tits cho một Tat

def fiftyfourtitsfortatfunc (num, nhiều hơn, vui vẻ, tôi, en):
    ngực = 54
    nếu "d" trong en [-tits:] hoặc num> = (200-ngực):
        trả lại "d"
    trả lại "c"

Một chàng trai tốt

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ố gắng để dự đoán đầu ra của đối thủ bằng cách nhìn vào lịch sử. Ví dụ: nếu các bước di chuyển cuối cùng là ( c, kẻ thù d), nó sẽ cố gắng tìm ra lần xuất hiện cuối cùng của các bước di chuyển chính xác.

Hackman [không đủ tiêu chuẩn]

Ok, cái này có lẽ sẽ bị loại khỏi cuộc thi, nhưng tôi thực sự cảm thấy muốn thử nó:

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"

Ở đây tôi lấy cơ sở là BackstabbingTitForTat đã được chứng minh là tốt nhất trong các mô phỏng của tôi. Ngoài ra, nó chủ yếu dựa vào việc sử dụng một biểu tượng không được sử dụng "#"(đó là lý do tại sao tôi nói rằng nó có thể sẽ bị loại trừ).

Bây giờ hãy để tôi giải thích các điều kiện ở đây:

Thứ 1: Đảm bảo hai Hackman hợp tác nếu có sự cố xảy ra.

Lần 2: Nếu tôi thua một bot khác, ít nhất sẽ khiến anh ta mất càng nhiều điểm càng tốt, vì vậy đó không phải là một kẻ thù lớn sau đó.

Lần 3: Phản bội một lượt trước, vì vậy thắng vs Backstabbing

sử dụng "#" thay vì "d" khiến tôi nhận được 0 điểm thay vì -1 và cũng giao tiếp với các Hackman khác có ít điểm hơn, vì vậy anh ta ngừng đào thoát.

Bizzaro

Liệu chính xác ngược lại với ăn miếng trả miếng. Khi một người nào đó tử tế với anh ta, anh ta thể hiện tình yêu của mình bằng cách xấu xa, và khi ai đó có nghĩa là anh ta thể hiện sự trả thù bằng cách tốt. Nặng nề dựa trên ăn miếng trả miếng.

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

6 Tits cho một Tat

def sixtitsforatatfunc (num, nhiều hơn, vui vẻ, tôi, en):
    nếu "d" trong en [-6:] hoặc num> = 194:
        trả lại "d"
    trả lại "c"

Tit cho cuộc chạy đua vũ trang Tat đang diễn ra :)

Mười Tits cho một Tat

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

Khiếm khuyết trước đó, và cũng có khuyết điểm nếu đối thủ của nó đã đào thoát trong mười lượt cuối cùng.

CopyFirst

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

Điều này làm hỏng vòng đầu tiên, sau đó làm bất cứ điều gì đối thủ đã làm vòng đầu tiên, cho đến vòng thứ 197, khi nó lùi lại.

Bốn mươi Tits cho một Tat

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

Nếu đối thủ đào thoát trong 40 lượt cuối, đào thoát, nếu không thì hợp tác. Backstab trong 50 lượt cuối cùng.

Ba Tits cho một Tat

Nếu đối thủ đào thoát trong 3 lượt cuối, đào thoát, nếu không thì hợp tác. Backstab trong 5 lượt cuối cùng. Chương trình này đã đánh cắp sự dẫn dắt từ Tit cho Two Tats bởi một biên độ hẹp.

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"

Năm Tits cho một Tat

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

Nếu bạn không thể hiểu được cái này làm gì, bạn là một thằng ngốc. Cũng backstabs một vòng trước đó.

Nhăn mặt

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

Mọi D khác

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

Mọi C khác

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

Các nhà toán học dự đoán:

Nhà toán học trẻ

Mới đối với sự khắc nghiệt của thế giới

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

Mathematiti cũ

Có nhiều kinh nghiệm hơn trong những vấn đề này

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

Tôi nghi ngờ một trong hai điều này sẽ làm tốt, nhưng ít nhất họ sẽ thêm cách để người khác có điểm!

Tit ngẫu nhiên cho 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 Cho Tất, nhưng ngẫu nhiên. Điều này sẽ không giành được bất kỳ giải thưởng nào (trừ khi tôi thực sự may mắn). Bây giờ với số ngẫu nhiên được tạo ra từ một nguồn thích hợp.

Khai thác tất cả

Khai thác Tat cố gắng chơi các chiến lược sau:

• Khiếm khuyết khi phía sau. Đó là cách duy nhất để bắt kịp.

• Hợp tác chống lại ăn miếng trả miếng và các chiến lược tương tự. Đó là cách duy nhất để có được điểm số dài hạn tốt.

• Khiếm khuyết chống lại luôn luôn hợp tác và các khối khác.

• Khiếm khuyết 5 vòng sớm.

Đây là mã:

def exploitativetatfunc(num, mypoints, enpoints, mylist, enlist):
    if mypoints < enpoints:
        return "d"
    if num >= 195:
        return "d"
    if num == 0:
        return "c"
    # Test defect, and keep defecting as long as they'll allow
    if (num == 5 or num >= 8) and all(choice == "c" for choice in enlist):
        return "d"
    # Recover if that goes wrong, and they were nice.
    if (num == 6 or num == 7) and all(choice == "c" for choice in enlist[:4]):
        return "c"
    # Otherwise, tit for tat.
    return enlist[-1]

30 Tits cho một Tat

def fiftitsfortatfunc (num, nhiều hơn, vui vẻ, tôi, en):
    ngực = 30
    nếu "d" trong en [-tits:] hoặc num> = (200-ngực):
        trả lại "d"
    trả lại "c"

Nhưng nếu ... câu trả lời tiếp theo không phải là kích hoạt nghiệt ngã hay thứ gì đó cho tat

tôi trình bày

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"

cáo

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

Khiếm khuyết nếu số vòng lớn hơn điểm kẻ thù, hợp tác khác.

Cậu bé

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"

Hợp tác vòng đầu tiên, sau đó hành động để ăn miếng trả miếng nhưng lại chống lưng trong năm vòng cuối cùng, và khiếm khuyết nếu không đi trước mười điểm.

53 ngực cho một tat

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

Tất cả các bạn đều biết đây là gì :)

Twentyfivetitsforatat

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

Kinda titsforatat

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

Kẻ phản bội thận trọng

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"

Giả sử nó đang chiến đấu với một n-tits-for-a-tatcon bot. Nếu nó có số điểm bị phản bội và vẫn giành chiến thắng, nó sẽ để cho bot khác đánh nó trước (chơi như ăn miếng trả miếng.) Nếu nó chỉ có thể thắng khi nó phản bội trước, Nó sẽ phản bội vào vòng 130, trước bất kỳ hiện tại nào người máy. Nếu nó có nhiều điểm sau đối thủ của mình, nó sẽ chỉ chơi kẻ đào ngũ trong nỗ lực hạ thấp điểm số bot không nghi ngờ.

Bắt tay

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"

Sử dụng mô hình cdccd trên năm vòng đầu tiên, để tìm hiểu nếu nó là với chính nó. Nếu vậy, nó sẽ cố gắng tối đa hóa điểm của mình bằng cách để bot có nhiều điểm hơn luôn bị lỗi, trong khi người kia luôn hợp tác. Nếu nó thấy nó đang chiến đấu với kẻ thù, nó sẽ đóng vai kẻ đào ngũ.

Trong các thử nghiệm của tôi, tôi thấy nó có liều tốt nếu nó chiếm một phần đáng kể trong dân số. Khi nó không có cơ hội chiến đấu với chính nó, về cơ bản nó sẽ bị giảm xuống thành một kẻ đào ngũ.

EDIT: Rõ ràng từ điểm số, họ có nhiều bot để điều này hoạt động tốt. Nó vẫn sẽ chiến thắng nếu chỉ chiến đấu vài ...

Kích hoạt Bizzaro

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

Luôn luôn hợp tác, trừ khi đối thủ của bạn từng hợp tác với bạn, trong trường hợp bạn khiếm khuyết. Luôn luôn.

FakeShake

tận dụng bắt tay - thực hiện một cái bắt tay sau đó chỉ là khuyết điểm trong khi bắt tay tin tưởng nó. Tuy nhiên, khi nó gặp chính nó, nó bắt tay 'thật'. Nếu nó gặp một bot khác, nó chơi ăn miếng trả miếng, với sự phản bội ở cuối. Cảm giác này có nghĩa là ...

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"

Một vấn đề với điều này là nếu nó đáp ứng bắt tay và nó có nhiều điểm hơn, nó nghĩ rằng nó tự chơi. Tôi là người mới chơi python và trang web này (thực tế đây là câu trả lời đầu tiên của tôi) vì vậy hãy chắc chắn nói với tôi nếu tôi có bất kỳ sai lầm ngu ngốc nào!