ในการท้าทายนี้คุณจะเขียนบอทที่เล่นเป็นภาวะที่กลืนไม่เข้าคายไม่ออกของนักโทษ นี่คือสิ่งที่คุณจะไม่สามารถเข้าถึงประวัติของเกมก่อนหน้านี้ แต่คุณจะสามารถเข้าถึงคู่ต่อสู้ได้ ในเวอร์ชั่นนี้ผู้เล่นทั้งสองจะได้รับ +2 คะแนนหากพวกเขาทั้งสองร่วมมือกัน +1 คะแนนหากพวกเขาทั้งคู่เสียและถ้าหากใครคนใดคนหนึ่งร่วมมือกัน แต่มีข้อบกพร่องอย่างใดอย่างหนึ่ง การส่งแต่ละครั้งจะถูกเล่นกับการส่งอื่น ๆ รวมถึงตัวเอง 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 วินาทีในรอบใดก็ตาม ในการบังคับใช้นี้จะมีการเลือกการหมดเวลาแบบสุ่มระหว่าง 1,000 มิลลิวินาทีและ 2000 มิลลิวินาที (เพื่อหลีกเลี่ยงการเล่นเกมโดยตั้งใจรอจำนวนเวลาที่ทราบ) และหากผู้ปฏิบัติงานใช้เวลานานกว่านั้นในการดำเนินการข้อผิดพลาดจะถูกโยนทิ้ง หากสิ่งนี้เกิดขึ้นสาเหตุของข้อผิดพลาดจะถูกกำหนดดังนี้: การดำเนินการจะถูกหยุดชั่วคราวในช่วงเวลาสุ่มหลังจาก 1000 มิลลิวินาทีและสแต็คการโทรในช่วงเวลานั้นจะถูกตรวจสอบ คู่แข่งรายล่าสุดที่เรียกว่าอยู่ในลูป (หรือเรียกซ้ำคล้ายลูปในแง่ที่ตั้งค่าการเรียกซ้ำเพื่อหลีกเลี่ยงข้อผิดพลาดสแต็คล้น) จะถูกตำหนิ หากคู่แข่งรายเดียวกันถูกตำหนิเนื่องจากทำให้เกิดข้อผิดพลาด "ใช้เวลานานเกินไป" หลายครั้งผู้แข่งขันรายนั้นจะถูกตัดสิทธิ์

Boombot

function boom(them) {
  throw 1;
}

หากฝ่ายตรงข้ามถูกเรียกใช้ก่อนและเรียกสิ่งนี้โดยไม่ต้องtry..catchบอทนี้จะชนะ 3 คะแนนโดยอัตโนมัติ ศูนย์คะแนนในกรณีอื่น ๆ

อาร์คีออปเทอริกซ์

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';
}

• หากฝ่ายตรงข้ามให้ความร่วมมือกับแล้วเลียนแบบย้ายของฝ่ายตรงข้ามกับcooperatedefect
• มิ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'));
}

• ถ้าข้อบกพร่องของฝ่ายตรงข้ามกับย้ายแล้วกลับของฝ่ายตรงข้ามกับcooperatedefect
• มิฉะนั้นถ้าฝ่ายตรงข้ามทำผิดพลาดdefectก็จะเสีย
• notNiceอื่นเลียนแบบของฝ่ายตรงข้ามกับการย้ายของ

อีกกลยุทธ์ที่สร้างวิวัฒนาการ

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 ไม่ชอบความร่วมมือ

ตรวจสอบสถานะ

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;
}

RandomBot

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

เพราะเหตุใด

ความซับซ้อน

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";
}

การทดสอบความซับซ้อนเพื่อดูว่าบอตนั้นร่วมมือหรือมีข้อบกพร่อง ถ้าเป็นก็ให้ความร่วมมือ แต่ถ้าไม่ใช่มันก็เป็นข้อบกพร่อง บอตปัจจุบันทั้งหมดที่ทดสอบคู่ต่อสู้ใช้ฟังก์ชั่นง่าย ๆ เพื่อทดสอบการตอบสนองดังนั้นความซับซ้อนจะหลอกว่าเป็นความร่วมมือในกรณีเหล่านั้น

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';
}

ฉันต้องการให้สิ่งนี้ทำงานได้เสมอเพื่อให้มีข้อบกพร่องเสมอยกเว้นเมื่อเล่นกับตัวเอง มันพยายามที่จะทำเช่นนั้นโดยผ่านฟังก์ชั่น "ผู้ทดสอบ" ซึ่งไม่ได้ห่อไว้กับพวกเขาและจะพยายามตรวจสอบว่า "พวกเขา" ชื่อผู้ทดสอบหรือไม่ หากเป็นชื่อผู้ทดสอบมันจะเปลี่ยนตัวแปรสแตติกที่เปิดใช้งานเป็นจริงจากนั้นส่งคืนความร่วมมือ แต่มันไม่ทำงาน ฉันไม่คุ้นเคยกับจาวาสคริปต์มากเกินไปและฉันจะทำการเปลี่ยนแปลงอีกครั้ง

ไม่ดี

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

เลียนแบบปฏิกิริยาของฝ่ายตรงข้ามเพื่อเบี่ยงเบน

ไม่ดี 2

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

รุ่นบูมหลักฐานของNotNice โดย FatalError

กึ๋น

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';
  }
}

คำเตือน:ฉันไม่รู้จักจาวาสคริปต์

หากคุณสามารถทำกำไรจากคนดีให้ทำ มิฉะนั้นคืนสิ่งที่พวกเขาจะกลับมาถ้าพวกเขาเผชิญหน้ากับความร่วมมือ (อย่างน้อยนั่นคือสิ่งที่ฉันคิดว่าทำ)

แล้วคุณจะไปไหน (แรงบันดาลใจจากความผันผวนในหนังสือของป่า)

    ทำงานด้วยตัวคุณเอง (พวกเขา) {
      ลอง{
        คืนพวกเขา (นี้);
      } catch (จ) {
        ส่งคืน "D";
      }
    }

   ฟังก์ชั่น yourself_no_this (พวกเขา) {
      ลอง{
        คืนพวกเขา (yourself_no_this);
      } catch (จ) {
        ส่งคืน "D";
      }
    }

ลงโทษผู้ตรวจ

ให้บอทโค้ดและดูว่ามันรันหรือไม่ ถ้ามันทำงานมากกว่าหนึ่งครั้งบอทนั้นเป็นผู้ตรวจสอบความชั่วและเราจะต้องเสียมัน! ถ้ามันถูกเรียกใช้ครั้งเดียวเล่นเป็นบอทที่ไม่ดี ถ้ามันไม่เคยทำงานให้ความร่วมมือ

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;
}

ผลการแข่งขัน 10,000 รอบ:

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

มัลพยายามที่จะตัดสินว่ามันอยู่ในการจำลองหรือไม่ หากเป็นเช่นนั้นจะถือว่ามันถูกส่งผ่านรหัสจริงในที่สุด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'));
  }
}

TrickyBot

พยายามคาดเดาไม่ได้

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

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

  return 'C';
}

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;
}

ไม่แน่ใจว่ามันสมเหตุสมผลหรือไม่ แต่ดูเหมือนน่าสนใจ! ทำเพื่อคุณในขณะที่คุณทำเพื่อตัวเองทำซ้ำเพื่อจับสุ่ม หากไม่ได้ผลก็ดีนะ

ยังไม่ได้ทดสอบและรหัส javascript แรกของฉันและซับซ้อนกว่าที่ฉันคาดไว้

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

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

ทำให้เกิดการวนซ้ำไม่สิ้นสุดซึ่งมีแนวโน้มว่าฝ่ายตรงข้ามจะถูกตำหนิ

Bot กฎแพลตตินัม

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

กฎทองคำขาวระบุว่า "ปฏิบัติต่อผู้อื่นในแบบที่พวกเขาต้องการได้รับการปฏิบัติ" บอทของฉันรองรับสิ่งนั้น สิ่งที่พวกเขาจะทำเพื่อตัวเองซึ่งเราถือว่าเป็นวิธีที่พวกเขาต้องการได้รับการปฏิบัติเราทำเพื่อพวกเขา หากพวกเขาโยนข้อผิดพลาดเราถือว่าพวกเขาต้องการร่วมมือ

TheGolfedOne (ชื่อ func:) a, 63 ไบต์

รหัส golfed อ่านยาก เพราะมันthemจะแตก
ฉันไม่เข้าใจกลไกของ KotH นี้อย่างถ่องแท้ แต่ฉันคิดว่าถ้าคู่ต่อสู้ไร้สัญชาติฉันก็ต้องทำลายมันในขณะที่ฉันเสีย

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

เขาไม่ได้ทำอะไรเลวร้ายอย่างที่ฉันคิดไว้ลองอันดับที่ 3 (ในจำนวนนั้น) ก่อน
ความพยายามครั้งที่สองaได้ 260 อีกครั้งอันดับที่ 3 อีกครั้งหลังonlyTrustYourselfและdefectอีกครั้ง มันอาจจะสอดคล้องกันในตอนท้าย :)

PS: ฉันไม่ค่อยเก่งกับการเล่นกอล์ฟดังนั้นมันจึงเป็นเรื่องตลกมากกว่าอะไร ที่นี่ฉันสั้นชื่อตัวแปรชื่อ func และลบช่องว่างให้มากที่สุดเท่าที่จะทำได้

กรรม

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

หากฝ่ายตรงข้ามจะร่วมมือกับเราเราจะร่วมมือกัน หากพวกเขาจะพยายามทำให้เสียเมื่อเราร่วมมือกันเราก็จะบกพร่องเช่นกัน