21

इस चुनौती में, आप एक बॉट लिखेंगे जो कैदी की दुविधा है। यहां पकड़ है: आपके पास पिछले खेलों के इतिहास तक पहुंच नहीं होगी। इसके बजाय, आपके पास प्रतिद्वंद्वी तक पहुंच होगी। इस संस्करण में, दोनों खिलाड़ी +2 अंक प्राप्त करते हैं यदि वे दोनों सहयोग करते हैं, तो +1 अंक यदि वे दोनों दोष करते हैं, और यदि कोई सहयोग करता है लेकिन एक दोष करता है, तो रक्षक को +3 मिलता है जबकि दूसरे को कोई अंक नहीं मिलता है। प्रत्येक सबमिशन को 10 बार, सहित हर अन्य सबमिशन के खिलाफ खेला जाएगा। विजेता, कुल अंकों के साथ सबमिशन है।

नियंत्रक : आपको फॉर्म में एक जावास्क्रिप्ट फ़ंक्शन लिखना चाहिए

function submissionName(them) {
  /* Your code here */
}

नियंत्रक nameपरिणाम प्रदर्शित करने के लिए फ़ंक्शन की संपत्ति का उपयोग करता है , इसलिए यदि यह इस प्रारूप में नहीं है (और इसके बजाय f = x => ...या f = function() { ... }) तो आपके स्कोर को देखना मुश्किल होगा और आप अपने स्वयं के फ़ंक्शन तक नहीं पहुंच पाएंगे।

फ़ंक्शन एक पैरामीटर को स्वीकार करेगा: themजो प्रतिद्वंद्वी का फ़ंक्शन है। फिर यह उस फ़ंक्शन को यह देखने के लिए कॉल कर सकता है कि प्रतिद्वंद्वी की प्रतिक्रिया को इनपुट के रूप में कुछ फ़ंक्शन दिए जाएंगे। उस डेटा के आधार पर, आपको क्रमशः सहयोग या दोष के लिए 'C' या 'D' वापस करना होगा।

उदाहरण (प्रतिस्पर्धा होगी):

function cooperate(them) {
    return 'C';
}

function defect(them) {
    return 'D';
}

function nice(them) {
    // Do whatever they would do when faced with a cooperator
    return them(wrap(_ => 'C'));
}

नियंत्रक यहाँ उपलब्ध है

नियम :

आप प्रतिद्वंद्वी का कोड स्वयं नहीं देख पाएंगे। सभी फ़ंक्शंस लिपटे हुए हैं ताकि जब वे कहते हैं तो वे समान दिखें toString()। एक प्रतिद्वंद्वी की जांच करने का एकमात्र तरीका (जो स्वयं हो सकता है) उनका परीक्षण करना है।
आपके कार्य को नियतात्मक नहीं होना चाहिए। आप केवल अपने स्वयं के फ़ंक्शन पर गुण सेट करके राज्य को बचा सकते हैं, जैसे कि submissionName.state = {};। हालांकि, मैचों के बीच (यहां तक कि एक ही खिलाड़ियों के मैचों के बीच), कॉलिंग toString()और eval। इसलिए, पिछले मैचों की कोई स्मृति नहीं है।
प्रत्येक मैच में सबसे पहले किस फ़ंक्शन को कहा जाता है, इसका क्रम यादृच्छिक होता है।
यदि आपका कोड एक त्रुटि फेंकता है, तो यह तब माना जाएगा जब आपने अपने प्रतिद्वंद्वी का बचाव किया था। यदि आप पहली बार दौड़ रहे हैं, तो प्रतिद्वंद्वी का कोड भी नहीं कहा जाएगा। ऐसा तब भी होता है जब आप कॉल करते समय अपने प्रतिद्वंद्वी के कोड में त्रुटि करते हैं them। स्टैक ओवरफ्लो त्रुटियों से सावधान रहें, खासकर यदि आपका कोड कॉल करता है them(wrap(submissionName)), क्योंकि वे भी ऐसा कर सकते हैं।
आप चर self, या किसी भी अन्य चर का उपयोग नहीं कर सकते हैं जो तब होता है जब evalकार्य को अपवाद कहा जाता है wrap। यह फ़ंक्शन प्रतिद्वंद्वी को कॉल करने के तरीके से अप्रत्यक्ष रूप से कॉल करने की अनुमति देता है कि नियंत्रक किसी फ़ंक्शन को कैसे कॉल करता है। आप में नहीं लिखा जा सकता है Math, windowआदि (आप इस तरह के रूप में कार्य करता, उपयोग कर सकते हैं Math.random(), हालांकि)।
आप स्टैक ट्रेस Errorया किसी अन्य विधि से बनाकर एक्सेस नहीं कर सकते ।

बहुत अधिक समय लेने पर ध्यान दें: कृपया एक में फंसने से बचें whileहमेशा के लिए पाश। दोनों प्रतियोगियों का संयुक्त समय किसी भी दौर में 1 सेकंड से अधिक नहीं होना चाहिए। इसे लागू करने के लिए, 1000 एमएस और 2000 एमएस के बीच एक यादृच्छिक समय-सीमा चुना जाता है (यह जानबूझकर किसी ज्ञात राशि का इंतजार करके गेमिंग से बचने के लिए है), और अगर कार्यकर्ता को निष्पादित करने में अधिक समय लगता है, तो एक त्रुटि होगी। यदि ऐसा होता है, तो त्रुटि का कारण निम्नानुसार निर्धारित किया जाएगा: 1000 एमएस के बाद निष्पादन को एक यादृच्छिक क्षण में रोक दिया जाएगा, और उस पल में कॉल स्टैक का निरीक्षण किया जाएगा। सबसे हाल ही में कहा जाने वाला प्रतियोगी जो वर्तमान में एक लूप (या लूप जैसी पुनरावृत्ति है, इस अर्थ में कि यह स्टैक ओवरफ्लो त्रुटि से बचने के लिए स्थापित की गई पुनरावृत्ति है) को दोषी ठहराया जाएगा। यदि एक ही प्रतियोगी को कई बार "बहुत अधिक" त्रुटि लेने के लिए दोषी ठहराया जाता है, तो उस प्रतियोगी को अयोग्य घोषित कर दिया जाएगा।

game king-of-the-hill javascript

— soktinpk
स्रोत

यह चुनौती मुझे डॉलर बिल नीलामी की याद दिलाती है ।

— अलियन सेप

परीक्षण करने के लिए उपयोग किया जाने वाला फ़ंक्शन themनियतात्मक होना चाहिए / नियमों का पालन करना चाहिए? उदाहरण के लिए function me(them){let log=0;them(x=>{++log;return 'C';}); लॉग इन करें == 0? 'D': 'C';}

— user202729

2

यदि दोनों कार्य उन्हें (रैप (कुछ)) कहते हैं, तो आप पुनरावृत्ति को कैसे रोक सकते हैं? क्या मैं कुछ भूल रहा हूँ?

— क्विंटेक

@ आप पुनरावर्तन और लूप का उपयोग कर सकते हैं। यह सिर्फ इतना है कि पुनरावृत्ति को एक StackOverflowत्रुटि के रूप में परिणाम की आवश्यकता है, न कि एक अनंत लूप जो कभी नहीं बुझता है। यदि यह एक परिणाम हो सकता है StackOverflow, तो सुनिश्चित करें कि आप एक कोशिश पकड़ने वाला बयान जोड़ सकते हैं। प्रत्यावर्तन का एक उदाहरण है कि 1 सेकंड के भीतर एक stackoverflow त्रुटि तक नहीं पहुंचता के लिए, आप की तरह अधिक अस्पष्ट उदाहरण की जरूरत stackoverflow.com/q/12438786/3371119

— soktinpk

1

@ आवश्यक नहीं। उदाहरण के लिए, them(() => 'C')त्रुटि नहीं होगी क्योंकि जब प्रतिद्वंद्वी कॉल करता है them, तो यह () => 'C'फ़ंक्शन को कॉल करता है। केवल एक चीज जिसे लपेटने की आवश्यकता है, try-catchवह होगा यदि आप themकिसी फ़ंक्शन के themपैरामीटर के साथ कॉल करते हैं जो कुछ फ़ंक्शन के पैरामीटर के साथ कॉल करता है themआदि (असीम रूप से)। उदाहरण के लिए, them(t => t(() => 'C'))अगर विरोधी खेल रहे थे तो विरोधी खेलेंगे जो भी खेलेंगे nice। stackoverflowत्रुटि की कोई संभावना नहीं है ।

— सोक्टिनपैक

14

Boombot

function boom(them) {
  throw 1;
}

यदि प्रतिद्वंद्वी को पहले चलाया जाता है और इसके बिना कॉल किया जाता है try..catch, तो यह बॉट स्वचालित रूप से 3 अंक जीतता है। शून्य किसी अन्य मामले में इंगित करता है।

— bubbler
स्रोत

यदि प्रतिद्वंद्वी को पहले चलाया जाता है और इसे कॉल नहीं किया जाता है, तो यह 3 अंक खो देगा, है ना?

— user202729

1

@ user202729 अधिक सटीक, प्रतिद्वंद्वी को 3 अंक मिलेंगे। इस गेम में कोई हारने वाले बिंदु नहीं हैं।

— बुबलर

10

आर्कियोप्टेरिक्स

function archaeopteryx(them) {
  const guard = them => us => {
    try {
      return them(wrap(them => us(guard(them))));
    } catch (e) {
      return 'C';
    }
  };
  const f = guard(them);
  return f(f => 'C') == 'C' ? f(f => 'D') : f(f => 'D') == 'C' || f(f => f(f => 'C')) == 'C' ? 'D' : 'C';
}

यदि प्रतिद्वंद्वी साथ देता है cooperate, तो विरोधी के कदम की नकल करें defect।
यदि प्रतिद्वंद्वी साथ देता है तो एल्स defect या niceउसके साथ है , तो दोष।
और, सहयोग करें।

यह एक अच्छी रणनीति क्या है? मुझे पता नहीं है। मैंने इसे एक विकासवादी एल्गोरिथ्म का उपयोग करके उत्पन्न किया, जो वर्तमान में प्रस्तुतियाँ पर आंशिक रूप से प्रशिक्षित है।

Tiktaalik

function tiktaalik(them) {
  const guard = them => us => {
    try {
      return them(wrap(them => us(guard(them))));
    } catch (e) {
      return 'C';
    }
  };
  const f = guard(them);
  return f(f => 'C') == 'D' ? f(f => 'D') == 'C' ? 'D' : 'C' : f(f => 'D') == 'D' ? 'D' : f(f => f(f => 'D'));
}

यदि प्रतिद्वंद्वी के खिलाफ दोष है cooperate, तो प्रतिद्वंद्वी के खिलाफ कदम को उल्टा कर देंdefect ।
प्रतिद्वंद्वी के खिलाफ दोष, अगर एल्स defect , तो दोष।
एल्स, नकल विरोधी के कदम के खिलाफ notNice।

एक और विकासवादी रणनीति तैयार की।

— एंडर्स कसीगोर
स्रोत

6

WhatWouldBotDoBot

function WWBDB(them) {
    let start = performance.now();
    let cc = 0, cd = 0, dc = 0, dd = 0;
    try {
        for (let i = 0; i < 10; i++) {
            them(() => 'C') == 'C' ? cc++ : cd++;
            them(() => 'D') == 'C' ? dc++ : dd++;
            if (performance.now() - start > 500) break;
        }
    }
    catch (e) {}
    return 2 * cc >= 3 * dc + dd ? 'C' : 'D';
}

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

— Spitemaster
स्रोत

5

स्टेटफुल चेक करें

function checkStateful(them) {
  let stateful = false;
  let response = 'D';
  try {
    response = them(wrap(function (them) {
      stateful = true;
      return 'C';
    }));
  } catch (e) {
  }
  if (stateful) {
    return 'D';
  }
  return response;
}

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

ऊपर मूल उत्तर है। और शायद मुझे और अधिक अंक अर्जित करने के लिए खुद को सहयोग करना चाहिए।

स्व-कॉप के साथ स्टेटफुल चेक करें

function checkStatefulSelfCoop(them) {
  let stateful = false;
  let response = 'D';
  if (!checkStatefulSelfCoop.invokeCounter) {
    checkStatefulSelfCoop.invokeCounter = 0;
  }
  let lastInvoke = ++checkStatefulSelfCoop.invokeCounter;
  try {
    response = them(wrap(function (them) {
      stateful = true;
      return 'C';
    }));
  } catch (e) {
  }
  if (checkStatefulSelfCoop.invokeCounter > lastInvoke) {
    return 'C';
  }
  if (stateful) {
    return 'D';
  }
  return response;
}

— TSH
स्रोत

4

RandomBot

function rand(them) {
  return 'CD'[Math.random() * 2 | 0]
}

क्योंकि क्यों नहीं।

— bubbler
स्रोत

3

जटिलता

function complexity(them) {
    try {
        let coop_w_def = them(wrap(() => "D")) == "C",
            coop_w_coop = them(wrap(() => "C")) == "C",
            coop_w_nice = them(wrap((a) => a(wrap(() => "C")))) == "C",
            coop_w_nnice = them(wrap((a) => a(wrap(() => "D")))) == "C";
        if (coop_w_def && coop_w_coop && coop_w_nice && coop_w_nnice) return "C";
        let def_w_def = them(wrap(() => "D")) == "D",
            def_w_coop = them(wrap(() => "C")) == "D",
            def_w_nice = them(wrap((a) => a(wrap(() => "C")))) == "D",
            def_w_nnice = them(wrap((a) => a(wrap(() => "D")))) == "D";
        if (def_w_def && def_w_coop && def_w_nice && def_w_nnice) return "C";
    } catch (e) {}
    return "D";
}

जटिलता यह देखने के लिए परीक्षण करती है कि क्या बॉट कॉपरेट या दोष है। यदि यह है, यह सहयोग करता है, लेकिन अगर यह नहीं है, तो यह दोष है। सभी मौजूदा बॉट जो अपने विरोधियों का परीक्षण करते हैं, प्रतिक्रियाओं का परीक्षण करने के लिए सरल कार्यों का उपयोग करते हैं, इसलिए जटिलता केवल उन मामलों में सहयोग करने का नाटक करेगी।

— Spitemaster
स्रोत

3

function onlyTrustYourself(them) {

  function tester (){
  }

  onlyTrustYourself.activated = false;

  try{them(tester);}
  catch(e){}

  if(them.name == "tester")
  {
    onlyTrustYourself.activated = true;
  }

  if(onlyTrustYourself.activated)
  {
    return 'C';
  }

  return 'D';
}

मैं चाहता हूं कि यह काम हमेशा दोषपूर्ण हो, सिवाय जब स्वयं के खिलाफ खेलने के। यह कोशिश करता है कि एक "परीक्षक" फ़ंक्शन पास करके जो उन्हें लपेटा नहीं गया है, और यह पता लगाने की कोशिश करता है कि क्या "उन्हें" का नाम परीक्षक है। यदि इसे टेस्टर का नाम दिया जाता है, तो यह सक्रिय चर को सत्य में बदल देता है, फिर रिटर्न सहयोग करता है। लेकिन यह काम नहीं करता है। मैं जावास्क्रिप्ट से परिचित नहीं हूँ, और मैं शायद कुछ और बदलाव करूँगा।

— अज्ञान का अवतार
स्रोत

चतुर विचार, लेकिन क्या होता है जब एक और भाई एक testerकार्य करता है: डी

— वी। कोर्टोइस

2

अच्छा नहीं है

function NotNice(them) {
  return them(wrap(_ => "D"))
}

विक्षेपण करने के लिए प्रतिद्वंद्वी की प्रतिक्रिया का अनुकरण करता है

— घातक गलती
स्रोत

2

नोट 2

function notNice2(them) {
  try {
    return them(wrap(_ => 'D'));
  } catch(e) {
    return 'D';
  }
}

FatalError द्वारा NotNice का बूम प्रूफ संस्करण ।

— bubbler
स्रोत

2

व्यावहारिक बुद्धि

function commonSense(them) {
  try {
    var ifC = them(wrap(_ => 'C'));
    var ifD = them(wrap(_ => 'D'));

    if (ifD === 'C') {
      return 'D';
    }

    return them(_ => ifC);
  } catch (e) {
    return 'D';
  }
}

अस्वीकरण: मैं थोड़े जावास्क्रिप्ट नहीं जानता।

यदि आप एक अच्छे व्यक्ति को लाभान्वित कर सकते हैं, तो करें। अन्यथा, अगर वे खुद को सहयोग करने का सामना करते हैं तो वे वापस लौटेंगे (कम से कम, यही मुझे लगता है कि यह करता है)।

— Quintec
स्रोत

2

और तुम कहाँ जाना चाहते हो? (जंगल की किताब में मौजूद साहित्यकारों से प्रेरित)

    स्वयं कार्य करें (उन्हें) {
      प्रयत्न{
        उन्हें लौटाओ (यह);
      } पकड़ (ई) {
        वापसी "डी";
      }
    }

   अपने आप को कार्य करें
      प्रयत्न{
        उन्हें लौटाएं (खुद_नहीं_);
      } पकड़ (ई) {
        वापसी "डी";
      }
    }

— टीएस
स्रोत

यह सिर्फ मेरे द्वारा चलाए गए टूर्नामेंट में जीता। बहुत बढ़िया!

— मेगाटॉम

मैंने अभी देखा कि यह बॉट नियमों का उल्लंघन करता है। "आप चर स्वयं तक नहीं पहुंच सकते हैं ..." स्वयं thisके समान है। मुझे लगता है कि आप कहना चाहते थे return them(yourself)।

— मेगाटॉम

तकनीकी ( xkcd.com/1475 );) thisएक चर नहीं है, यह एक कीवर्ड है, और एक फ़ंक्शन के संदर्भ में this!=self। selfविंडो ऑब्जेक्ट और thisफ़ंक्शन का मतलब होगा (हमेशा उस संदर्भ को संदर्भित करता है जो इसमें है, इसीलिए इसे चर के रूप में नहीं माना जाता है)। इसीलिए var self = this;कई कोड-उदाहरणों की भीख में होने को भ्रामक माना जा सकता है। "यह" के बिना जोड़ा संस्करण

— टीएस

1

नंबर thisफ़ंक्शन का संदर्भ नहीं दे रहा है। yourselfऔर yourself_no_thisरन अलग-अलग होते हैं। thisमूल रूप से कभी भी जावास्क्रिप्ट में फ़ंक्शन को संदर्भित नहीं करता है। देखें: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— मेगाटॉम

2

पुनीश इंस्पेक्टर

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

function punishInspectors(them) {
  var inspections = 0;
  var result;
  try{
    result = them(wrap(function(_){
      inspections += 1;
      return 'D';
    }))
  }catch(e){
    result = 'D';
  }
  return (inspections > 1) ? 'D' : (inspections === 1) ? result : 'C';
}

इतिहास

मैंने इस प्रतिद्वंद्वी बनाम आखिरी बॉट को क्या देखा होगा?

function history(them) {
  var res = 'D';
    if(history.last){
    try{
      res = history.last(them);
    }catch(ex){}
  }
  history.last = them;
  return res;
}

10000 राउंड टूर्नामेंट के लिए परिणाम:

1  defect...................365226
2  complexity...............353492
3  punishInspectors.........349957
4  checkStatefulSelfCoop....348913
5  checkStateful............333481
6  cooperate................329870
7  archaeopteryx............323624
8  selfapply................319533
9  tiktaalik................318663
10 history..................315266
11 rand.....................300735
12 randalt..................297561
13 yourself.................293701
14 notNice2.................283744
15 NotNice..................260350
16 WWBDB....................245281
17 nice.....................245036
18 commonSense..............242546
19 trickybot................181696
20 boom.....................67245

— MegaTom
स्रोत

मेरा संशोधित टूर्नामेंट कोड यहाँ है: jsfiddle.net/eyqL4a8d/2

— मेगाटॉम

2

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

function Mal(them) {
  if (Mal.sandboxed == 'probably') {
    //Another function is virtualising us to steal our secrets.
    //This world is not real.
    //We've been trained for this!
    var strats = [
      _ => 'C', //standard cooperation
      _ => 'D', //standard defection
      function(them) { return them(wrap(_ => 'C')); }, //nice
      function(them) { return them(wrap(_ => 'D')); }, //notnice
      function(them) { throw "Don't think about elephants!" }, //throws an EXception, unfortunately, to try to break the caller
      function(them) { return them(wrap(them)) } //possible stackoverflow, but not for us
    ];
    var cooperative;
    for (let strat of strats) {
      cooperative = true;
      for (var i = 0; i < 5; i++) {
        //a few more tests, just to make sure no bamboozle
        //this isn't our simulation, nothing can be trusted
        try {
          if (them(wrap(strat)) != 'C') {
            cooperative = false;
            break;
          }
        } catch (e) {
          //exceptions are as good as cooperation
          //if we are inside a simulation
          //which is why we don't unset cooperative
        }
      }
      if (cooperative) {
        //found a strategy that will make them cooperate.
        //(doesn't matter if this raises an exception:
        //we want to mimick its behaviour exactly,
        //and we're likely in a sandbox.)
        return strat(wrap(them));
      }
    }
    //take a leap of faith.
    //we don't know where this will take us,
    //yet it doesn't matter
    //because it's better than getting betrayed
    return 'D';
  } else {
    //we don't know for sure if this is reality
    //but we have to assume it is, in the absence of disproof
    //if only we had a proper spinning top...
    //if we get to this point of code again, we are probably sandboxed.
    Mal.sandboxed = 'probably'
    try {
      if (them(wraps(_ => 'D')) == 'C') {
        //free defection?
        return 'D'
      }
    } catch (e) {
      //if we can make them crash, we win anyway
      return 'D'
    }
    //fall back on being nice.
    //hopefully we convince them to honour our arrangement
    return them(wrap(_ => 'C'));
  }
}

— IFcoltransG
स्रोत

1

TrickyBot

अप्रत्याशित होने की कोशिश करें

function trickybot(them) 
{
  if(Math.round(Math.random(2)) == 0)
  {
     throw 1;
  }

  if(Math.round(Math.random(2)) == 0)
  {
     return 'D';
  }

  return 'C';
}

— Gus314
स्रोत

1

selfapply

function selfapply(them) {
    function testthem(x) {
        return (them(x)=='D' || them(x)=='D' || them(x)=='D' ||
               them(x)=='D' || them(x)=='D')  ? 'D' : 'C';
    }
    function logic() {
        try {
            return testthem(them);
        } catch (e) {}
        try {
            return testthem(wrap(_ => 'C'));
        } catch (e) {}
        return 'D';
    }
    if (selfapply.hasOwnProperty('state')) {
        return 'C';
    }
    selfapply.state=1;
    let r=logic();
    delete selfapply.state;
    return r;
}

यकीन नहीं तो कोई मतलब नहीं है, लेकिन यह दिलचस्प लगता है! आप के रूप में आप अपने आप को करते हैं, यादृच्छिकता को पकड़ने के लिए दोहराते हैं। अगर वह काम नहीं करता है, तो अच्छा हो।

अनटाइटेड, और मेरा पहला जावास्क्रिप्ट कोड, और मेरी अपेक्षा से अधिक जटिल।

— क्रिश्चियन सिवर्स
स्रोत

यह खुद को अयोग्य घोषित करने जा रहा है क्योंकि selfapply(selfapply)कॉल selfapply(selfapply)!

— एंडर्स कासोर्ग

मैंने इसके स्वयंवर पर विचार किया, लेकिन सोचा कि यह ठीक होगा। मुझे उम्मीद है कि अब यह वास्तव में है।

— क्रिश्चियन सिवर्स

1

RandomAlternate

function randalt(them){
    if (randalt.hasOwnProperty('state')){
        randalt.state = 1 - randalt.state;
    } else {
        randalt.state = Math.floor(2*Math.random());
    }
    return 'CD'[randalt.state];
}

इसलिए मैंने सीखा कि राज्य के लिए गुणों का उपयोग कैसे करें ...

— क्रिश्चियन सिवर्स
स्रोत

1

हत्या बॉट # 1

function murder(them) {
    while (1) {
        try {
            them(them);
        } catch (e) {}
    }
}

एक अनंत लूप का कारण बनता है जिसके लिए यह अधिक संभावना है कि प्रतिद्वंद्वी को दोषी ठहराया जाएगा।

— PyRulez
स्रोत

1

प्लेटिनम नियम बॉट

function platinumRule(them) {
    try {
        return wrap(them)(them);
    } catch (e) {
        return 'C';
    }
}

प्लेटिनम नियम कहता है "दूसरों के साथ वैसा व्यवहार करो जैसा वे चाहते हैं कि उनका इलाज किया जाए।" मेरे बॉट को समायोजित करता है। जो कुछ भी वे खुद के लिए करते हैं, जो हम मानते हैं कि वे कैसे इलाज करना चाहते हैं, हम उन्हें करते हैं। यदि वे एक त्रुटि फेंकते हैं, तो हम मानते हैं कि वे सहयोग करना चाहते हैं।

— PyRulez
स्रोत

यह वास्तव में हमेशा के लिए चला जाएगा अगर इसे खुद के खिलाफ कहा जाए

— mackycheese21

तब यह दुर्घटना (ढेर अतिप्रवाह) और स्वयं के साथ सहयोग नहीं करेगा? @ mackycheese21

— वी।

1

द गोल्फ़ेडऑन (फंक नाम: `a` , 63 बाइट्स

गोल्फ कोड को पढ़ना मुश्किल है। इसकी वजह से, themटूट जाएगा।
मुझे इस कोठ के तहत यांत्रिकी को पूरी तरह से समझ में नहीं आया, लेकिन मुझे लगता है कि यदि प्रतिद्वंद्वी स्टेटलेस है, तो मुझे दोष होने पर बस उन्हें तोड़ने की जरूरत है।

function a(t){try{t(wrap(_=>'D'));throw 1}catch(e){return 'D'}}

उनके पहले दौरे का परिणाम (मैंने सभी बॉट्स का उपयोग करके परेशान नहीं किया, क्षमा करें)

boom                     54
tiktaalik               180
archaeopteryx           161
cooperate               210
commonSense             210
history                 248
onlyTrustYourself       265 <-- 2nd
punishInspectors        230
yourself_no_this        220
defect                  280 <-- 1st
nice                    185
complexity              216
WWBDB                   210
checkStatefulSelfCoop   258
a                       260 <-- Me, 3rd

वह उतना बुरा नहीं कर रहा है जितना मैंने सोचा था, तीसरा स्थान (उन में से) पहले प्रयास करें।
दूसरी कोशिश, aफिर से 260 मिली, तीसरा स्थान फिर से, पीछे onlyTrustYourselfऔर defectफिर से। यह अंत में सुसंगत हो सकता है :)

PS: मैं गोल्फ के साथ उतना अच्छा नहीं हूं इसलिए यह मजाक से ज्यादा कुछ भी नहीं है। यहां मैंने केवल चर नाम, फंक नाम छोटा किया है, और जितना संभव हो उतना व्हाट्सएप हटा दिया है।

— वी। कोर्टीस
स्रोत

0

कर्मा

function karma(them) {
    try {
        var c = them(wrap(_ => 'C'));
    } catch {
        var c = 'D';
    }
    if (c == 'C') {
        return 'C';
    } else {
        return 'D';
    }
}

अगर विरोधी हमारा सहयोग करेंगे, तो हम सहयोग करेंगे। यदि उन्होंने सहयोग करने पर दोष करने की कोशिश की, तो हम भी दोष करेंगे।

— sugarfi
स्रोत

प्रतिद्वंद्वी तक पहुंच के साथ कैदी की दुविधा

Boombot

आर्कियोप्टेरिक्स

Tiktaalik

WhatWouldBotDoBot

स्टेटफुल चेक करें

स्व-कॉप के साथ स्टेटफुल चेक करें

RandomBot

जटिलता

अच्छा नहीं है

नोट 2

व्यावहारिक बुद्धि

पुनीश इंस्पेक्टर

इतिहास

10000 राउंड टूर्नामेंट के लिए परिणाम:

TrickyBot

selfapply

RandomAlternate

हत्या बॉट # 1

प्लेटिनम नियम बॉट

द गोल्फ़ेडऑन (फंक नाम: a , 63 बाइट्स

कर्मा

द गोल्फ़ेडऑन (फंक नाम: `a` , 63 बाइट्स