Dans ce défi, vous écrirez un bot qui joue le dilemme du prisonnier. Voici le hic: vous n'aurez pas accès à l'historique des jeux précédents. Au lieu de cela, vous aurez accès à l'adversaire lui-même. Dans cette version, les deux joueurs gagnent +2 points s'ils coopèrent tous les deux, +1 points s'ils font tous les deux défaut, et si l'un coopère mais un défaut, le transfuge gagne +3 tandis que l'autre n'obtient aucun point. Chaque soumission sera jouée contre chaque autre soumission, y compris elle-même, 10 fois. Le gagnant est la soumission avec le plus de points.

Contrôleur : vous devez écrire une fonction javascript, sous la forme

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

Le contrôleur utilise la namepropriété de la fonction pour afficher les résultats, donc s'il n'est pas dans ce format (et est à la place f = x => ...ou f = function() { ... }), il sera difficile de voir votre score et vous ne pourrez pas accéder à votre propre fonction.

La fonction acceptera un paramètre: themqui est la fonction de l'adversaire. Il peut alors appeler cette fonction pour voir quelle réaction de l'adversaire se verrait attribuer certaines fonctions en entrée. Sur la base de ces données, vous devez renvoyer «C» ou «D» respectivement pour coopérer ou pour défaut.

Exemples (seront en compétition):

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

Le contrôleur est disponible ici

Règles :

• Vous ne pourrez pas voir le code de l'adversaire lui-même. Toutes les fonctions sont encapsulées de sorte qu'elles se ressemblent lors de l' toString()appel. La seule façon d'examiner un adversaire (qui pourrait être vous-même) est de le tester.
• Votre fonction n'a pas à être déterministe. Vous ne pouvez enregistrer l'état qu'en définissant des propriétés sur votre propre fonction, telles que submissionName.state = {};. Cependant, entre les matchs (même entre les matchs des mêmes joueurs), l'état est effacé en appelant toString()et eval. Par conséquent, il n'y a pas de mémoire des correspondances précédentes.
• L'ordre dans lequel la fonction est appelée en premier dans chaque correspondance est aléatoire.
• Si votre code renvoie une erreur, il sera traité comme si vous aviez coopéré pendant que votre adversaire faisait défection. Si vous êtes le premier à courir, le code de l'adversaire ne sera même pas appelé. Cela se produit même si l'erreur se produit dans le code de votre adversaire pendant que vous appelez them. Méfiez-vous des erreurs de débordement de pile, surtout si votre code appelle them(wrap(submissionName)), car elles pourraient faire de même.
• Vous ne pouvez pas accéder à la variable selfou à toute autre variable qui se trouve être dans la portée lorsqu'elle evalest appelée SAUF la fonction wrap. Cette fonction vous permet d'appeler l'adversaire d'une manière qui ne se distingue pas de la façon dont le contrôleur appelle une fonction. Vous ne pouvez pas écrire Math, windowetc. (Vous pouvez utiliser des fonctions telles que Math.random(), cependant).
• Vous ne pouvez pas accéder à la trace de pile en créant un Errorou par une autre méthode.

Une note pour prendre trop de temps: veuillez éviter de rester coincé dans un whileboucle pour toujours. Le temps combiné des deux concurrents ne doit pas dépasser 1 seconde dans une manche donnée. Pour appliquer cela, un timeout aléatoire entre 1000 ms et 2000 ms est choisi (c'est pour éviter de jouer en attendant intentionnellement un temps connu), et si le travailleur met plus de temps à s'exécuter, une erreur sera lancée. Si cela se produit, la cause de l'erreur sera déterminée comme suit: l'exécution sera interrompue à un moment aléatoire après 1000 ms et la pile d'appels à ce moment sera inspectée. Le concurrent le plus récemment appelé qui est actuellement dans une boucle (ou une récursion de type boucle, dans le sens où il s'agit d'une récursivité configurée pour éviter une erreur de débordement de pile) sera blâmé. Si le même concurrent est blâmé d'avoir causé plusieurs fois une erreur de "prise trop longue", ce concurrent sera disqualifié.

BoomBot

function boom(them) {
  throw 1;
}

Si l'adversaire est exécuté en premier et l'appelle sans try..catch, ce bot gagne automatiquement 3 points. Zéro point dans tous les autres cas.

Archéoptéryx

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

• Si l'adversaire coopère cooperate, imitez le mouvement de l'adversaire defect.
• Sinon, si l'adversaire coopère avec defectou avec nice, alors défaut.
• Sinon, coopérez.

Qu'est-ce qui en fait une bonne stratégie? Je n'ai aucune idée. Je l'ai généré en utilisant un algorithme évolutif, formé en partie sur les soumissions actuelles.

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

• Si l'adversaire fait défaut contre cooperate, alors inversez le mouvement de l'adversaire contre defect.
• Sinon, si l'adversaire fait défaut defect, alors il fait défaut.
• Sinon, imitez le mouvement de l'adversaire notNice.

Une autre stratégie générée par l'évolution.

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 est assez simple; il teste simplement son adversaire pour ce qu'il ferait contre un programme en régime permanent. Si un bot préfère coopérer si possible, WWBDB préfèrera également la coopération (donc il coopérera avec le gentil bot). La WWBDB ne préfère pas elle-même la coopération.

Vérifier avec état

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

S'ils m'invoquent, alors ils seront probablement vraiment eux. Nous agissons comme transfuge. S'ils ne m'invoquent pas, alors ils seront probablement un testeur emballé. Nous serions plus gentils.

Ci-dessus est la réponse originale. Et peut-être que je devrais me faire une coopération pour gagner plus de points.

Vérifiez l'état avec l'auto-coop

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

Parce que pourquoi pas.

Complexité

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

Tests de complexité pour voir si le bot est Coopérer ou Défaut. S'il l'est, il coopère, mais s'il ne l'est pas, il fait défaut. Tous les bots actuels qui testent leurs adversaires utilisent des fonctions simples pour tester les réponses, donc Complexity fera simplement semblant de coopérer dans ces cas.

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

Comment je veux que cela fonctionne, c'est toujours un défaut, sauf en jouant contre soi-même. Il essaie de le faire en passant une fonction "testeur" qui ne leur est pas encapsulée, et il essaie de détecter si "eux" est nommé testeur. S'il est nommé testeur, il change la variable statique activée en true, puis renvoie coopère. Mais ça ne marche pas. Je ne suis pas trop familier avec javascript, et je vais probablement apporter quelques modifications supplémentaires.

Pas gentil

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

Imite la réaction de l'adversaire à la déviation

NotNice 2

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

Version anti-boom de NotNice par FatalError .

Bon sens

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

Avertissement: je ne connais pas javascript.

Si vous pouvez profiter d'une bonne personne, faites-le. Sinon, restituez ce qu'ils retourneraient s'ils se trouvaient confrontés à une coopération (du moins, c'est ce que je pense que cela fait).

Et toi, où veux-tu aller? (inspiré des volumes du livre de la jungle)

    fonctionner vous-même (eux) {
      essayer{
        retournez-les (ceci);
      } catch (e) {
        retourner "D";
      }
    }

   fonctionner vous-même_non_ce (eux) {
      essayer{
        retournez-les (vous-même_non_cette);
      } catch (e) {
        retourner "D";
      }
    }

Punir les inspecteurs

Donnez du code au bot et voyez s'il l'exécute. S'il a été exécuté plus d'une fois, le bot est un mauvais inspecteur, et nous devons faire défaut! Si elle a été exécutée exactement une fois, jouez comme un robot pas sympa. S'il n'a jamais été exécuté, coopérez.

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

Histoire

Que ferait le dernier bot que j'ai vu contre cet adversaire?

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

Résultats pour un tournoi à 10000 tours:

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

Mal essaie de déterminer si c'est à l'intérieur d'une simulation ou non. Si c'est le cas, il suppose que le vrai code lui sera finalement transmis themet essaie diverses stratégies pour les convaincre de coopérer.
S'il ne sait pas avec certitude, il vérifie s'il peut être défectueux gratuitement, ou sinon, essaie de copier ce themqui ferait quand on lui donnerait un coopérateur.

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

Essayez d'être imprévisible

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

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

  return 'C';
}

autoappliquer

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

Je ne sais pas si cela a du sens, mais cela semble intéressant! Faites-vous comme vous le faites pour vous-même, répétez pour attraper le hasard. Si cela ne fonctionne pas, soyez gentil.

Non testé, et mon premier code javascript, et plus complexe que ce à quoi je m'attendais.

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

J'ai donc appris à utiliser les propriétés pour l'état ...

Assassiner Bot # 1

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

Provoque une boucle infinie dans laquelle il est plus probable que l'adversaire sera blâmé.

Le robot de la règle du platine

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

La règle de platine stipule "Traitez les autres comme ils veulent être traités". Mon bot accepte cela. Quoi qu'ils se fassent, ce que nous supposons être la façon dont ils voudraient être traités, nous le faisons pour eux. S'ils lancent une erreur, nous supposons qu'ils veulent coopérer.

TheGolfedOne (nom de fonction:) a, 63 octets

Le code golfé est difficile à lire. À cause de cela, themva se casser.
Je n'ai pas bien compris la mécanique sous ce KotH, mais je suppose que si l'adversaire est apatride, j'ai juste besoin de les briser pendant que je fais défaut.

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

Résultat de son premier tournoi (je n'ai pas pris la peine d'utiliser tous les bots, désolé)

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

Il ne fait pas aussi mal que je le pensais, 3ème place (parmi ceux-ci) premier essai.
Deuxième essai, aj'ai encore 260, 3e encore, derrière onlyTrustYourselfet defectencore. Cela pourrait être cohérent à la fin :)

PS: Je ne suis pas très bon avec le golf, donc c'est plus pour la blague qu'autre chose. Ici, je n'ai raccourci que les noms de variable, le nom de fonction et supprimé autant d'espaces que possible.

Karma

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

Si l'adversaire veut coopérer avec nous, alors nous coopérerons. S'ils essayaient de faire défaut lorsque nous avons coopéré, nous ferons aussi défaut.