एक पागल वैज्ञानिक ने सिर्फ जीवाणु की एक नई प्रजाति बनाई है! उन्होंने इसे नोबेलस जेंटलमैनस नाम देने का फैसला किया है, उसके व्यवहार को देखने के बाद। हालांकि, उसके बैक्टीरिया भोजन से बाहर भाग गए हैं, और युद्ध की घोषणा की है, क्योंकि वे स्वयं की प्रतियां बनाने के लिए पर्याप्त भोजन के लिए अन्य जीवाणु की लाशों की कटाई करने में सक्षम हैं। इस जीवाणु की विभिन्न उप-प्रजातियां हैं, जिनके पास कैदी की दुविधा, उनका पसंदीदा खेल खेलने की अलग-अलग रणनीतियाँ हैं। प्रत्येक अलग-अलग उप-प्रजाति से पांच बैक्टीरिया होते हैं। कैदी की दुविधा में, दो खिलाड़ियों में से प्रत्येक एक साथ दोष या सहयोग चुनता है। यदि एक खिलाड़ी सहयोग का चयन करता है और दूसरा डिफ़ॉल्ट का चयन करता है, तो डिफॉल्टर को 2 अंक मिलते हैं, और कूपरेटर 3 अंक खो देता है। यदि दोनों खिलाड़ी सहयोग चुनते हैं, तो दोनों खिलाड़ियों को एक अंक मिलता है। यदि दोनों खिलाड़ी डिफ़ॉल्ट चुनते हैं, तो दोनों खिलाड़ी 1 अंक खो देते हैं।

नोबल जेंटलमैन होने के नाते, बैक्टीरिया ने Iterated Prisoner की दुविधा के 200 गोल लंबे खेल खेलकर इस युद्ध को लड़ने का फैसला किया है। प्रत्येक द्वंद्वयुद्ध में हारने वाला आत्महत्या कर लेगा, जिससे जीतने वाला खुद का क्लोन बना सकेगा। एक टाई की स्थिति में, दोनों बैक्टीरिया जीवित रहेंगे, लेकिन न तो स्वयं क्लोन कर पाएंगे। इसके अलावा, एक मैच से सभी बैक्टीरिया अपने अगले मैच में 10% से अधिक अंक ले जाते हैं। एक क्लोन उस जीवाणु के बिंदुओं पर ले जाता है, जिसके द्वारा इसे क्लोन किया गया था। इसके अलावा, प्रत्येक दस बारी में एक मौका होता है कि एक जीवाणु 0 उप-बिंदुओं के साथ एक और उप-प्रजाति में बदल जाएगा (यदि मुझे इस की यादृच्छिकता के बारे में शिकायत मिलती है, तो मैं इसे हटा सकता हूं)। बैक्टीरिया दस बार बैक्टीरिया की उप-प्रजाति की संख्या के बराबर इन duels की एक संख्या निभाई है के बाद, पागल वैज्ञानिक गलती से पेट्री डिश बैक्टीरिया में रहते हैं बूँदें, और सभी बैक्टीरिया भोजन के नए स्रोतों को प्राप्त करते हैं, जिससे उनकी ग्रहणी समाप्त हो जाती है। यह एक साधारण iterated कैदी की दुविधा प्रतियोगिता से अलग है, क्योंकि इसमें कैरीओवर पॉइंट्स के साथ 1v1 duels शामिल हैं, बल्कि कुल मिलाकर सबसे अधिक अंक प्राप्त करने का प्रयास किया गया है। यह इस बात में बड़ा बदलाव करता है कि दी गई रणनीति कितनी प्रभावी है।

प्रत्येक जीवाणु प्रारूप में अपनी बारी की शुरुआत में इनपुट प्राप्त करेगा: (टर्न नंबर, करंट पॉइंट्स, दुश्मन पॉइंट्स, आपकी पिछली चालें [एक स्ट्रिंग में, सहयोग के लिए वर्ण "c" का उपयोग करके, और दोष के लिए वर्ण "d") ], दुश्मन पिछली चाल [उसी प्रारूप में])।

यहां चार सैंपल स्ट्रैटेजी हैं जिन्हें दर्ज किया जाएगा। मुझे वास्तव में लगता है कि डिफेक्टर जीत सकता है, भले ही यह बेहद सरल हो।

जैसे को तैसा

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

RandomPick

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

सहकार्मी

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

दलबदलू

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

सभी प्रस्तुतियाँ एक पायथन 2.7 फ़ंक्शन के रूप में होनी चाहिए, जिसका नाम funcअंत के साथ कोई रिक्त स्थान के साथ प्रस्तुत करने का नाम नहीं है । यदि कोई व्यक्ति किसी अन्य भाषा में उत्तर प्रस्तुत करना चाहता है, तो कृपया इसे छद्म-कूट में दर्ज करें, मेरे लिए मेरे उत्तर में एक बार अपने उत्तर को संपादित करने के लिए अजगर में परिवर्तित कर दें, या मुझे अपने नियंत्रक के साथ अपनी भाषा को बदलने के निर्देश दें 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

तो, ऐसा प्रतीत होता है कि परफेक्ट जेंटलमैन विजेता है। ड्रेको 18 को बधाई, जो निश्चित रूप से उनके ग्रीन चेकमार्क के हकदार हैं।

king-of-the-hill python

— Gryphon
स्रोत

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

1

नोट: यदि आप अपने कार्यक्रम को पूरा कर रहे हैं, तो कृपया मुझे सूचित करें कि मैं एक नोटिस दे सकता हूं, या यह एक निशान के लिए स्कोर पर मत डालिए !!!!!!!!!!!!!!!!!!!! !!!

— ग्रिएफॉन

ओह! मुझे एहसास हुआ कि कितने आयात हैं।

— Gryphon

1

हे Gryphon, आप उन अंतिम रैंकिंग पर काम कर रहे हैं? ;)

— Draco18s अब

क्षमा करें, मैं इस बारे में भूल गया। मुझे इसे चलाने के लिए थोड़ा दे दो।

— Gryphon

8

एकदम सही जेंटलमैन

मेरे पास इस बॉट के लिए अच्छा विवरण नहीं है। मैं संभावित अनुकूलन के एक जोड़े में ठोकर खाई, उनका परीक्षण किया, ठीक ट्यून किया, और एक बैक्टीरिया के साथ समाप्त हो गया जो पूरी तरह से प्रतियोगिता को नष्ट कर देता है। इसके बजाय, मैंने यह बताने के लिए कोड की टिप्पणी की कि वह क्या करता है।

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%) प्राप्त करता है।

मैंने अभी तक अपने परीक्षणों में गणितज्ञों को नहीं जोड़ा है, हालांकि उन दोनों को केवल मौजूदा रणनीतियों को खिलाने के लिए सेवा करनी चाहिए और परिणाम में बहुत बदलाव नहीं करना चाहिए।

यह अपने नियंत्रण के एक अच्छे हिस्से का प्रबंधन प्रॉपर्टी के माध्यम से करता है, लेकिन इसे नियमों के अनुसार अनुमति दी गई थी (उदाहरण रणनीतियों को लक्षित करने के लिए उचित खेल था)। गेम ऑफ थ्रोन्स के प्रचार का भी इसका एक साइड इफेक्ट है , लेकिन यह अनजाने में था क्योंकि दोनों मेरे द्वारा चुने गए मानदंडों के आधार पर अप्रभेद्य हैं। उन "रक्षक प्रकार" के बाद राउंड 2 में एक बिंदु-लाभ होता है और परिणामस्वरूप कई परेशानी वाले पड़ोसियों को बाहर निकालते हैं (एन-टी 4 टी प्रकार) और जब वे द परफेक्ट जेंटलमैन का खंडन करते हैं, तो वे अपने बिंदु लाभ का विस्तार करते हैं और तेजी से खपत करते हैं।

लगभग 5% संभावना है कि सभी परफेक्ट जेंटलमैन पहले राउंड में डिफेक्ट-टाइप के साथ जोड़ी बनाए और सामूहिक आत्महत्या कर लें। जिस स्थिति में, n-T4t प्रकारों में से एक कुल वर्चस्व (196 की 196 कोशिकाओं) को प्राप्त करता है। बहुत कम ही अन्य प्रकारों में से एक (गेम ऑफ थ्रोंस, बॉय, ग्रिमेस, सोर लॉस) ... पूरी तरह से विलुप्त नहीं होने और एक या दो अंक हासिल करने का प्रबंधन करते हैं।

वर्तमान सिमुलेशन (अभी भी 200 कुल खेलों की ओर प्रगति में है)। सभी प्रविष्टियाँ स्कोरिंग 0 निकाली गईं। गेम ऑफ थ्रोन्स और 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

टाट के लिए बैकस्टैबिंग टाइट (क्षमा के साथ)

यह मूल रूप से टाट के लिए लकी टिट (क्षमा के साथ टाट के लिए उर्फ टाइट) है जो एक मोड़ के साथ "हल" इष्टतम समाधान ("भाग्यशाली" के कुछ मूल्य के लिए) है। जैसा कि हम जानते हैं कि गेम कितने राउंड तक चलेगा, यह बैक्टीरिया फाइनल राउंड में बैकस्टैब करता है और इस तरह से टैट और कोपरेटर बैक्टीरिया के लिए किसी अन्य टाइट के खिलाफ शुद्ध लाभकारी परिणाम सुनिश्चित करता है (खुद के खिलाफ यह एक शून्य शून्य के साथ समाप्त होता है, जैसे कि यह था सहयोग किया)। 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 राउंड के दौरान कम से कम एक बार एक जैतून की शाखा की पेशकश करते हैं, और जैसा कि बिटर टाट समग्र रूप से पीछे है, यह वसूली के लिए एक हताश बोली में उन 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"

बीट टाट को टिट फॉर टाट के खिलाफ अन्य बॉट के व्यवहार और उन परिणामों में व्यक्त किए गए पैटर्न को देखते हुए बनाया गया था, लेकिन उन रणनीतियों को स्पष्ट रूप से काउंटर करने के लिए डिज़ाइन नहीं किया गया है: यह अभी भी एक सामान्य उद्देश्य फार्मूला है।

अतिरिक्त कड़वा टाट

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"

अतिरिक्त जल्दी ख़राब होने से अतिरिक्त कड़वा।

— Draco18s को अब SE पर भरोसा नहीं है
स्रोत

1

कृपया अपने फ़ंक्शन का नाम बदलें, क्योंकि यह पहले से ही लिया गया है।

— ग्रिफन

@Gryphon वूप्स, माफ करना, मुझे एहसास नहीं था कि मैंने ऐसा किया है। मैं वास्तव में पायथन में कोड नहीं करता, मैंने कोड के दो बिट्स को एक साथ मिटाया।

— Draco18s अब SE

1

I suspect it will outperform NeoAnticapitalist by a small margin। 30,000 से अधिक अंकों की तरह।

— ग्रिफन

1

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— Draco18s अब SE

2

मैं सराहना करता हूं कि आपने इस कोथ को मजाक नहीं बनाने के लिए एक बॉट बनाया

— विनाशकारी नींबू

8

Anticapitalist

एक और सरल। यहां तक कि मैचों के लिए (एक ही स्कोर पर शुरू) टिटफॉरट की तरह व्यवहार करता है, लेकिन मुख्य विचार मैच को जीवित करने की कोशिश कर रहा है।

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"

NeoAnticapitalist

एंटीकैपिटलिस्ट का एक सुधार (या तो मुझे लगता है)। मुझे अंतिम मोड़ पर सहयोग करने का कोई कारण नहीं दिख रहा है। मुझे इस बात का भी कोई कारण नहीं दिखता कि जब मैं निश्चित रूप से अपने प्रतिद्वंद्वी से नहीं मिलूंगा।

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"

— Masclins
स्रोत

मैं वास्तव में हैरान हूं कि मैंने ऐसा नहीं सोचा, लेकिन यह शानदार है। मुझे नहीं पता कि यह जीतेगा, लेकिन मुझे लगता है कि इसे बहुत अच्छा काम करना चाहिए।

— ग्रीफॉन

@Gryphon ने एक नया बॉट जोड़ा (और मेरे दो अन्य लोगों को मिला दिया)

— मैस्किन्स

@ ग्रिफॉन दोनों संस्करणों के लिए धन्यवाद

— मैस्किन्स

कोई बात नहीं, @AlbertMasclans

— Gryphon

मेरे द्वारा चलाए जा रहे सिमुलेशन से, NeoAnticapitalist ने बैकस्टैब टाइट से टैट के लिए बढ़त ले ली है।

— ग्रीफॉन

6

पछतावा करने वाला अग्रेसिव

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"

यह हर बार दोषपूर्ण, और इसके लिए टिट-फॉर-टेट-आधारित रणनीतियों को हराने के लिए, डिफेक्टर के साथ "रखने" के लिए डिज़ाइन किया गया है।

मूल विचार यह है कि हम दोष की शुरुआत करते हैं, लेकिन यदि प्रतिद्वंद्वी ने 1 का सहयोग किया है, तो हम एक पारस्परिक पुनरावृत्ति चक्र से बचने के लिए दो बार सहयोग करते हैं, इस प्रकार एक बड़े दंड से बचते हैं। (यदि, हालांकि, प्रतिद्वंद्वी बाद में दोष करता है, तो हम अपने आप को चक्र नहीं तोड़ते हैं; हम उन्हें ऐसा करेंगे और संभवत: खेल को खो देंगे।) फिर खेल के अंत में, हम एक यादृच्छिक समय चुनते हैं। अंतिम 5 के भीतर दुश्मन को बैकस्टैब में बदल देता है, जिससे हमें उनसे एक और अधिक दोष मिलता है और इस प्रकार अर्थ है कि जब तक हम कैरीओवर पॉइंट्स पर बहुत पीछे नहीं थे, हम प्रक्रिया में कैरीओवर के मामले में बहुत त्याग किए बिना, जीतते हैं । (समय अवधि को बेतरतीब करने का मतलब है कि हम बैकस्टैब के साथ पहली बार मिलने की संभावना रखते हैं, यह भी कि यह रणनीति पहले से एक मोड़ पर बैकस्टैब करने के उद्देश्य से "विरुद्ध नहीं" हो सकती है।)

— Gryphon
स्रोत

आपके नंबर 3 पर बधाई! +1

— ग्रीफॉन

6

गंभीर ट्रिगर

सरल बॉट, प्रतियोगिता की कोशिश करने और भरने के लिए

यह तब तक सहयोग करेगा, जब तक कि दुश्मन दोष न हो, जिस स्थिति में यह अक्षम्य रूप से दोष करता है

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

ठीक है, ऐसा लगता है कि यह ntitsfortat मेटा जल्दी ख़राब होने के कारण काम नहीं करता है

— विनाशकारी नींबू
स्रोत

आपके नंबर 5 पर बधाई, +1।

— ग्रीफॉन

@ सलफ़र मैं सोच रहा था कि ऐसा कौन होगा? _; ठीक है

— विनाशकारी नींबू

5

गेम ऑफ़ थ्रोन्स

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 पीछे हैं जिस स्थिति में शुरुआती विश्वासघात जीत जाएगा।

— रॉबर्ट फ्रेजर
स्रोत

आपके तीसरे स्थान पर बधाई! +1

— ग्रीफॉन

और अब दूसरे तक!

— ग्रिएफॉन

गेम ऑफ थ्रोंस बॉट के खिलाफ काफी लड़ाई डाल रहा है जिसका मैं अभी परीक्षण कर रहा हूं। सरल रणनीति इसके लिए अच्छी तरह से काम कर रही है।

— Draco18s अब

4

लकी टिट फॉर टैट

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"

मुझे पूरा यकीन है कि मैंने कहीं पढ़ा कि टाट के लिए सबसे अच्छी रणनीति थी। मैंने इसे अन्य कार्यक्रमों के लिए एक संभावना बनाने का फैसला किया ताकि कुछ विविधता को जोड़ने के लिए खुद को भुना सकें। अब एक उचित यादृच्छिक संख्या जनरेटर के साथ (यह मुझे एक फायदा देता है?)।

— एलेक्स
स्रोत

मूल रूप से, यह जीतने की रणनीति है, हाथ नीचे, हर समय जैसा कि विकिपीडिया पर दिया गया है । एकमात्र विचरण एक टाइट-फॉर-टेट दोष-चक्र (जो अन्य सभी प्रविष्टियों के मिलान पर निर्भर करता है) से बाहर तोड़ने की संभावना में है।

— Draco18s को अब SE

1

@ Draco18s यह एक अलग स्कोरिंग प्रणाली के लिए जीतने की रणनीति है, कुल अंक स्कोरिंग प्रणाली। बेसिक टिट-फॉर-टेट कभी एक राउंड नहीं जीत सकता, अगर वह राउंड में कुछ अंक नहीं लेगा, तो यह अच्छा नहीं होगा।

— इसहाक

@ आईसैक सही है, यही कारण है कि यह रणनीति अब 18 में से 14 वें स्थान पर है (हालांकि मुझे इसके लिए एएच एल को दोष देने का कोई अधिकार नहीं है क्योंकि 18 वें कार्यक्रम में से एक मेरा है।)

— ग्रिएफॉन

4

हाथी

हाथी कभी नहीं भूलता!

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 अंक की बढ़त होती है, तो वह कुछ पायदान हासिल करने के लिए दोष देगा।

और अंत में, अगर उसे लगता है कि उसका प्रतिद्वंद्वी सहयोग करेगा, और उसके पास एक मजबूत नेतृत्व है, तो वह सहयोग करेगा।

— Ataco
स्रोत

मैं कुछ इस तरह की प्रतीक्षा कर रहा था जो नाइस गाय से बेहतर काम करे। हालाँकि, मैं इसका परीक्षण लगभग 8 घंटे तक नहीं कर पाऊंगा, इसलिए मुझे लगभग 12-13 में अपडेट करने में सक्षम होना चाहिए।

— ग्रीफॉन

4

एक टाट के लिए 54 स्तन

डीईएफ़ फ़ोर्टफ़ुटस्फ़ोर्टफ़ैटफ़ुनक (संख्या, अधिक, मज़ेदार, मुझे, एन):
    स्तन = ५४
    यदि "d" एन में [-tits:] या संख्या> = (200-स्तन):
        वापसी "डी"
    वापसी "ग"

— एलेक्स
स्रोत

मुझे आश्चर्य है कि क्या यह अभी भी जीतेगा?

— ग्रीफॉन

यह अभी जीत रहा है!

— ग्रिफ़ोन

बधाई हो, आपने मेरे दोनों शीर्ष बॉट्स को हरा दिया है!

— ग्रिफ़ोन

@Gryphon अगर मैं अपने अन्य बॉट्स के लिए इतना संलग्न नहीं होता तो मैं एक टैट के लिए 5 स्तन बना लेता हूं :)

— एलेक्स

मुझे लगता है कि वक्र के दूसरी तरफ जा रहा होगा। मैं हालांकि खुद एक परीक्षण कर सकता हूं!

— ग्रीफॉन

3

अच्छा लड़का

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) थीं , तो यह ठीक उसी चाल की अंतिम घटना को खोजने की कोशिश करती है।

— CommonGuy
स्रोत

3

हैकमैन [अपेक्षित रूप से अयोग्य]

ठीक है, यह शायद प्रतियोगिता से बाहर हो जाएगा, लेकिन मुझे वास्तव में ऐसा लगता है:

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: अगर मैं एक अलग बॉट के खिलाफ हारने जा रहा हूं, तो कम से कम उसे अधिक से अधिक अंक खोना चाहिए, इसलिए यह एक बहुत बड़ा दुश्मन नहीं है।

3: पहले एक मोड़ को धोखा दें, इसलिए जीतता है बैकस्टैबिंग

"d" के बजाय "#" का उपयोग करने से मुझे -1 के बजाय 0 अंक मिलते हैं और अन्य हैकमैन के साथ भी संवाद होता है जिनके पास कम अंक होते हैं, इसलिए वह दोष करना बंद कर देता है।

— Masclins
स्रोत

2

क्षमा करें, लेकिन अयोग्य। यह निर्णय लेने की प्रक्रिया के साथ खिलवाड़ करता है। आप प्रत्येक मोड़ पर "c" या "d" अवश्य लौटाएँ।

— ग्रीफॉन

2

हालांकि, यह बहुत आविष्कारशील है, इसलिए मुझे इसे अयोग्य घोषित करने के लिए खेद है।

— ग्रिफ़ोन

3

bizzaro

क्या टाइट के लिए टाइट के ठीक विपरीत है। जब कोई उसके प्रति दयालु होता है तो वह बुराई के द्वारा अपने प्यार को दिखाता है, और जब कोई ऐसा होता है तो वह अच्छा होने के द्वारा बदला दिखाता है। शीर्षक के लिए शीर्षक के आधार पर भारी।

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

— TitusLucretius
स्रोत

दिलचस्प। यह हालांकि दोषियों द्वारा मारा जा रहा है।

— ग्रीफॉन

@Gryphon Lmao, वास्तव में यह एहसास नहीं था। लेकिन हे, बिजोदरो सही और गलत के बीच कोई अंतर नहीं जानता, जीत और हार।

— टाइटस ल्यूक्रेटियस

हाँ, यह सहकर्मी के प्रति सहकर्मी और रक्षक की ओर कूपर होगा, जो कुछ दिलचस्प संभावनाओं के लिए बना सकता है। यह वास्तव में स्वयं सहित किसी अन्य चीज के साथ सह-अस्तित्व में नहीं हो सकता है।

— ग्रीफॉन

@Gryphon, हाँ इसे 0 मिलना चाहिए, जब यह खुद खेलता है। आश्चर्य है कि कोमल दोष के साथ क्या होगा।

— टाइटस ल्यूक्रेटियस

आश्चर्य है कि क्या होता है जब यह टैट के लिए बैकस्टैबिंग टाइट का सामना करता है, जो इस सबमिशन से पहले जीत रहा था।

— ग्रीफॉन

3

एक टाट के लिए 6 स्तन

डीईएफ़ सिक्सिट्सफोरटैटफंक (संख्या, अधिक, मज़ा, मुझे, एन):
    यदि "d" एन में [-6:] या अंक> = 194:
        वापसी "डी"
    वापसी "ग"

टाट हथियारों की दौड़ के लिए टाइट हो रहा है :)

— एलेक्स
स्रोत

मुझे लगता है कि हम ओवरबोर्ड जा रहे हैं और डिफेक्टर शीर्ष स्थान पर चोरी करेगा।

— ग्रीफॉन

3

एक टाट के लिए दस स्तन

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"

यदि आप यह पता नहीं लगा सकते कि यह क्या करता है, तो आप एक बेवकूफ हैं। इसके अलावा एक दौर पहले।

— Gryphon
स्रोत

IMO, अपनी प्रविष्टि सबमिट करने के लिए स्वतंत्र महसूस करें।

— अब ड्रेको

अगर यह आम तौर पर उचित माना जाता है तो अभी निश्चित नहीं था।

— ग्रीफॉन

हालांकि, आम तौर पर यह आम बात है कि सर्वश्रेष्ठ उत्तर जीतने वाला बॉट है।

— मैक्लिंस

यह होगा, मैं सिर्फ अपना जवाब नहीं चुनूंगा। यह निश्चित रूप से उचित नहीं होगा।

— ग्रिफन

मैं माफी माँगता हूँ, मुझे एहसास नहीं था कि मैंने गलती से अपना जवाब स्वीकार कर लिया है। यह अब अस्वीकार्य है, और मैं 1 जुलाई के रूप में सबसे अच्छा जवाब स्वीकार करूँगा

— ग्रिफ़ॉन

3

मुंह बनाना

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

— विनाशकारी नींबू
स्रोत

यह इस तरह का महसूस करता है कि इस पहाड़ी के लिए "इष्टतम" समाधान कुछ इस तरह से है (n4 के साथ T4nT मूल रूप से यह है), और जब यह दांव लगाता है तो केवल गोल का अनुकूलन करें। अधिक रचनात्मक कुछ भी नष्ट हो जाएगा।

— रॉबर्ट फ्रेजर

3

हर दूसरे डी

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

हर दूसरे सी

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

— स्टीफन
स्रोत

हो सकता है कि आपको सहयोग से शुरू होने वाली एक और प्रविष्टि प्रस्तुत करनी चाहिए।

— Gryphon

बस सोचा कि यह दिलचस्प हो सकता है।

— ग्रिफन

3

पूर्वज्ञात गणितज्ञ:

युवा गणितज्ञ

दुनिया की कठोरता के लिए नया

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'

मुझे संदेह है कि इनमें से कोई भी अच्छा करेगा, लेकिन कम से कम वे दूसरों को अंक प्राप्त करने के तरीके जोड़ेंगे!

— Panda0nEarth
स्रोत

इनमें से कुछ भी अच्छा नहीं हो रहा है, हे। वे सभी करते हैं, अधिकांश भाग के लिए दोषियों को खिलाते हैं।

— Draco18s अब

2

टाट के लिए यादृच्छिक शीर्षक

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"

तैसा टाट के लिए, लेकिन यादृच्छिक। यह कोई पुरस्कार जीतने वाला नहीं है (जब तक कि मैं वास्तव में भाग्यशाली नहीं हूं)। अब एक उचित स्रोत से उत्पन्न यादृच्छिक संख्याओं के साथ।

— एलेक्स
स्रोत

2

एक्सप्लोसिव टैट

शोषणपूर्ण टाट निम्नलिखित रणनीतियों को निभाने की कोशिश करता है:

पीछे होने पर दोष। यह पकड़ने का एकमात्र तरीका है।
टिट-फॉर-टेट और इसी तरह की रणनीतियों के खिलाफ सहयोग करें। यह एक अच्छा दीर्घकालिक स्कोर प्राप्त करने का एकमात्र तरीका है।
हमेशा सहकारी समितियों और अन्य chumps के खिलाफ दोष।
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]

— isaacg
स्रोत

मुझे आश्चर्य है कि यह 8 वें के लिए टाई से बेहतर नहीं था, लेकिन मुझे लगता है कि यह इसके लिए सिर्फ गलत समय था, और दुर्भाग्य से एक टाट के लिए दो स्तन के रूप में एक ही समय में प्रवेश किया गया था।

— ग्रीफॉन

2

एक टाट के लिए 30 स्तन

डीईएन टिट्सफोर्टफैटफंक (संख्या, अधिक, मज़ा, मुझे, एन):
    स्तन = ३०
    यदि "d" एन में [-tits:] या संख्या> = (200-स्तन):
        वापसी "डी"
    वापसी "ग"

— एलेक्स
स्रोत

2

लेकिन क्या अगर ... अगला जवाब गंभीर ट्रिगर या tat के लिए कुछ नहीं था

में प्रस्तुत करता हू

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"

— विनाशकारी नींबू
स्रोत

इंटरस्टिंग, घर जाने पर परीक्षण करूंगा।

— ग्रिफन

2

लोमड़ी

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"

आप सभी जानते हैं कि यह क्या है :)

— लोमड़ी की तरह का
स्रोत

2

Twentyfivetitsforatat

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"

— क्रिस्टोफर
स्रोत

अगली बार जब आप एक कार्यक्रम जोड़ने के लिए संपादित करते हैं, तो कृपया एक टिप्पणी भी जोड़ें ताकि मैं सतर्क हो जाऊं। धन्यवाद!

— ग्रिएफॉन

@Gryphon ओह सॉरी

— क्रिस्टोफर

2

विवेकपूर्ण विश्वासघात

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बॉट से लड़ रहा है । यदि इसमें धोखा दिया जाना है और फिर भी जीतना है, तो यह दूसरे बॉट को पहले हिट करने देगा (टाइट के रूप में खेलना)। बॉट। यदि यह अपने प्रतिद्वंद्वी के पीछे कई बिंदुओं पर है, तो यह बिना सोचे-समझे बॉट्स स्कोर को कम करने के प्रयास में रक्षक की भूमिका निभाएगा।

हाथ मिलाना

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पहले पांच राउंड पर , यह पता लगाने के लिए कि क्या यह स्वयं के साथ है। यदि ऐसा है, तो यह बोट को हमेशा अधिक दोष के साथ होने के द्वारा अपने बिंदुओं को अधिकतम करने की कोशिश करेगा, जबकि दूसरा हमेशा सहयोग करता है। यदि यह पाता है कि यह एक दुश्मन से लड़ रहा है, तो यह रक्षक की भूमिका निभाएगा।

मेरे परीक्षणों में, मुझे यह अच्छी तरह से खुराक लगता है अगर यह आबादी का एक महत्वपूर्ण हिस्सा बनाता है। जब यह खुराक में खुद से लड़ने का मौका नहीं होता है, तो यह मूल रूप से एक रक्षक के लिए कम हो जाएगा।

EDIT: स्पष्ट रूप से स्कोर से, उनके लिए यह काम करने के लिए कई बॉट हैं। यह अभी भी जीत जाएगा अगर सिर्फ शीर्ष कुछ लड़ ...

Bizzaro ट्रिगर

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

हमेशा सहयोग करें, जब तक कि आपका विरोधी कभी भी आपका साथ न दे, जिस स्थिति में आप दोष करते हैं। हमेशा।

— MegaTom
स्रोत

@Gryphon गले में खराश को हटा दिया गया था, और एक नया बॉट जोड़ा गया!

— मेगाटॉम

टेस्ट में अब मैं एक बॉट पर दौड़ रहा हूं, जिसे मैंने अभी तक पोस्ट नहीं किया है, हैंडशेक 390 गेम्स (5338 बचे हुए बॉट) के बाद 54 वें स्थान पर है, जो लगभग 1200 तक 54-टी 4 टी से आगे निकल गया है। मेरा नया बॉट उससे भी ज्यादा मजबूत है, हालांकि । प्रारंभिक परीक्षणों में यह 196 में से 196 स्कोरिंग था, हालांकि लंबे समय तक यह औसतन 124 / खेल स्कोर कर रहा है। दिलचस्प रूप से पर्याप्त है, हैंडशेक के पीछे का आधार वह था जो मैं आगे की कोशिश करने जा रहा था, पता चला कि आपने इसे बिना मेरी समझ के मुझे हरा दिया।

— Draco18s अब

0

FakeShake

हैंडशेक का फायदा उठाता है- हैंडशेक करता है तो सिर्फ दोष जबकि हैंडशेक इस पर भरोसा करता है। जब यह अपने आप से मिलता है, हालांकि, यह 'असली' हाथ मिलाना है। अगर यह एक अलग बॉट से मिलता है, तो यह अंत में एक विश्वासघात के साथ, टाट के लिए शीर्षक निभाता है। यह थोड़े मतलब लगता है ...

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"

इसके साथ एक समस्या यह है कि अगर यह हैंडशेक से मिलता है और इसमें अधिक अंक हैं, तो यह सोचता है कि यह अपना खेल है। मैं अजगर के लिए एक नौसिखिया हूँ और यह साइट (वास्तव में यह मेरा पहला जवाब है) इसलिए मुझे यह बताना सुनिश्चित करें कि क्या मैंने कोई बेवकूफ गलतियाँ की हैं!

— Arkine
स्रोत

PPCG में आपका स्वागत है!

— लकोनी

@ लायकोनी धन्यवाद!

— आर्किन

कैदी की दुविधा v.3 - पेट्री दुविधा

जैसे को तैसा

RandomPick

सहकार्मी

दलबदलू

यह प्रतियोगिता अब समाप्त हो गई है

अंतिम स्कोर !!!!!

एकदम सही जेंटलमैन

टाट के लिए बैकस्टैबिंग टाइट (क्षमा के साथ)

कड़वा टाट

अतिरिक्त कड़वा टाट

Anticapitalist

कोमल दोष

NeoAnticapitalist

पछतावा करने वाला अग्रेसिव

गंभीर ट्रिगर

गेम ऑफ़ थ्रोन्स

लकी टिट फॉर टैट

हाथी

एक टाट के लिए 54 स्तन

अच्छा लड़का

हैकमैन [अपेक्षित रूप से अयोग्य]

bizzaro

एक टाट के लिए 6 स्तन

एक टाट के लिए दस स्तन

CopyFirst

एक टाट के लिए चालीस स्तन

एक टाट के लिए तीन स्तन

एक टाट के लिए पाँच स्तन

मुंह बनाना

हर दूसरे डी

हर दूसरे सी

पूर्वज्ञात गणितज्ञ:

युवा गणितज्ञ

पुराने गणितज्ञ

टाट के लिए यादृच्छिक शीर्षक

एक्सप्लोसिव टैट

एक टाट के लिए 30 स्तन

anty

लोमड़ी

लड़का

एक टाट के लिए 53 स्तन

Twentyfivetitsforatat

किन्दा स्तनफरतत

विवेकपूर्ण विश्वासघात

हाथ मिलाना

Bizzaro ट्रिगर

FakeShake