Défi:

Créez un programme ou une fonction qui prend une entrée entière, qui génère un nouveau programme / fonction comme spécifié ci-dessous.

Contribution:

Entier n: temps en secondes avant l'explosion de la bombe à retardement.

Production:

Le programme d'origine qui avait le temps en secondes nen entrée, sortira un nouveau programme / fonction qui fait ce qui suit:

• Des nsecondes se sont-elles écoulées depuis l'exécution du programme précédent? ImpressionBOOM!
• Sinon: Imprime un programme / fonction qui, une fois exécuté lui-même, réinitialise le temporisateur à nquelques secondes (et agit de la même manière que le premier programme / fonction sorti).

REMARQUE: Ce n'est pas exactement le même que le premier programme / fonction sorti (dans la plupart des langues au moins), car l'heure de début a changé (voir l'exemple de clarification ci-dessous).

Exemple de pseudo-code:

Disons que le programme d'origine est ABCet l'entrée est en 60secondes:

ABCet 60sorties DEF(60).

• Si DEF(60)est exécuté dans les 60 secondes, il sortira DEF_G(60), ce qui sera exactement le même que DEF(60), mais avec une nouvelle heure de démarrage.
• Si DEF(60)est exécuté après 60 secondes, il sortira BOOM!.

Exemple de clarification de ce que je veux dire par «heure de départ»:

1. Le programme de base avec des 60secondes d' entrée est exécuté à 12:00:00. Il sort le premier programme de sortie avec une heure de début de 12:00:00.
2. Ce premier programme de sortie avec l'heure de début de 12:00:00est exécuté à 12:00:45. Il émet un deuxième programme de sortie avec une heure de début de 12:00:45.
3. Ce troisième programme de sortie avec une heure de début 12:00:45est exécuté à 12:01:25. Il sort un quatrième programme de sortie avec une heure de début de 12:01:25.
4. Ce quatrième programme de sortie avec une heure de démarrage 12:01:25est exécuté à 12:05:00. Il sortira BOOM!.

Notez comment la première sortie s'imprime BOOM!ensuite 12:01:00, mais le programme de sortie a progressé, même s'il se trouve 12:01:25à l'étape 3, il restitue le programme suivant au lieu de BOOM!(car les programmes de sortie de sortie ont des heures de démarrage au-delà de ce premier programme de sortie) .

Règles du défi:

• Les règles de quine par défaut s'appliquent.
• Au moins nquelques secondes auraient dû s'écouler. Donc, si l'entrée est 60et l'heure de début était 12:00:00, 12:01:00elle produira toujours le programme v2, mais 12:01:01elle produira BOOM!.
• Les programmes de sortie ne prendront aucune entrée ( sauf pour un paramètre inutilisé vide s'il est plus court ). L'heure de début doit être donnée aux programmes suivants en tant que valeur «codée en dur» (c'est pourquoi la sortie d'un programme de sortie n'est pas exactement la même que la précédente (dans la plupart des langues).
• Seule la taille de votre programme / fonction principale est comptée en termes d'octets.
• Vous pouvez sortir le programme / la fonction soit sous forme de chaîne (ou dans un format raisonnable comparable, comme un tableau d'octets / caractères / liste), comme fonction si votre langue le prend en charge, soit dans d'autres formats raisonnables (veuillez demander si vous n'êtes pas sûr).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

JavaScript, 51 octets

f=(t,o=setTimeout(_=>o=0,t*1e3))=>_=>o?f(t):'BOOM!'

Tester dans le navigateur

ancienne version

f=(t,o=0)=>{setTimeout(()=>o=1,t*1000);return ()=>o?'BOOM!':f(t)}

Tester dans le navigateur

JavaScript, 53 octets

f=(d,t=1/0,n=Date.now()/1e3)=>n>t?'BOOM!':_=>f(d,d+n)

g=
f=(d,t=1/0,n=Date.now()/1e3)=>n>t?'BOOM!':_=>f(d,d+n)

// please notice that `delay` may take longer time than experted time on a slow / busy machine
// which may lead an incorrect result
delay=n=>new Promise(r=>setTimeout(r,n*1e3));

assertFine=s=>console.log(s!=='BOOM!'?s:'FAIL');
assertBoom=s=>console.log(s==='BOOM!'?s:'FAIL');

(async function () {
  console.log('start test');
  let p1 = g(3);
  assertFine(p1); // should not boom
  await delay(2);
  let p2 = p1();
  assertFine(p2); // should not boom
  await delay(2);
  let b1 = p1();
  assertBoom(b1); // should boom
  let p3 = p2();
  assertFine(p3); // should not boom
  await delay(2);
  let b2 = p2();
  assertBoom(b2); // should boom
}());

Ancienne réponse (le retour devrait être une chaîne)

JavaScript, 78 octets

(f=(o,t,d)=>(x=d,n=Date.now()/1e3)=>o&&n>t?'BOOM!':`(f=${f})(${[1,n+x,x]})`)()

g=
(f=(o,t,d)=>(x=d,n=Date.now()/1e3)=>o&&n>t?'BOOM!':`(f=${f})(${[1,n+x,x]})`)()

// please notice that `delay` may take longer time than experted time on a slow / busy machine
// which may lead an incorrect result
delay=n=>new Promise(r=>setTimeout(r,n*1e3));

assertFine=s=>console.log(s!=='BOOM!'?s:'FAIL');
assertBoom=s=>console.log(s==='BOOM!'?s:'FAIL');

(async function () {
  console.log('start test');
  let p1 = g(3);
  assertFine(p1); // should not boom
  await delay(2);
  let p2 = eval(p1)();
  assertFine(p2); // should not boom
  await delay(2);
  let b1 = eval(p1)();
  assertBoom(b1); // should boom
  let p3 = eval(p2)();
  assertFine(p3); // should not boom
  await delay(2);
  let b2 = eval(p2)();
  assertBoom(b2); // should boom
}());

Java 8, 234 octets

n->"v->{long t=System.nanoTime();t/=1e9;String s=\"v->{long t=System.nanoTime();t/=1e9;String s=%c%s%1$c;return t-%d>"+n+"?%1$cBOOM!%1$c:s.format(s,34,s,t);}\";return t-"+(System.nanoTime()/1e9)+">"+n+"?\"BOOM!\":s.format(s,34,s,t);}"

Désolé de poster mon propre défi tout de suite. Il est principalement destiné à clarifier davantage le défi, et je me demandais s'il fallait l'ajouter à la question elle-même ou l'afficher en tant que réponse (et j'ai décidé de l'afficher comme une réponse pour ne pas encombrer le message du défi).
Et même si je voudrais dire que c'est aussi quelque chose à (essayer) de battre, cela ne vaut même pas la peine d'être mentionné car, eh bien ... Java (presque) est toujours battu. ; p

Essayez-le en ligne.

Exemple de sortie:

v->{long t=System.nanoTime();t/=1e9;String s="v->{long t=System.nanoTime();t/=1e9;String s=%c%s%1$c;return t-%d>60?%1$cBOOM!%1$c:s.format(s,34,s,t);}";return t-70492.687613232>60?"BOOM!":s.format(s,34,s,t);}

Essayez la fonction lambda sortie ici.

Exemple de sortie:

v->{long t=System.nanoTime();t/=1e9;String s="v->{long t=System.nanoTime();t/=1e9;String s=%c%s%1$c;return t-%d>60?%1$cBOOM!%1$c:s.format(s,34,s,t);}";return t-70548>60?"BOOM!":s.format(s,34,s,t);}

Explication:

La fonction principale prend une entrée entière et renvoie une chaîne. Il renvoie essentiellement une fonction qui est une quine, avec l'entrée entière et l'heure de début (en secondes comme horodatage) en tant que valeurs codées en dur.

Fonction principale:

n->        // Method with integer parameter and String return-type
  "v->{long t=System.nanoTime();t/=1e9;String s=\"v->{long t=System.nanoTime();t/=1e9;String s=%c%s%1$c;return t-%d>"
          //  First part of the output-function
  +n      //  With the integer input placed as hard-coded value
  +"?%1$cBOOM!%1$c:s.format(s,34,s,t);}\";return t-"
          //  The second part of the output-function
  +(System.nanoTime()/1e9)
          //  With the current time in seconds as hard-coded starting time
  +">"+n  //  And the integer input again (for the output of the output function)
  +"?\"BOOM!\":s.format(s,34,s,t);}"
          //  The final part of the output-function

n=60 a été utilisé dans les exemples ci-dessous:

Premier programme de sortie:

v->{                   // Method with empty unused parameter and String return-type
  long t=System.nanoTime();t/=1e9;
                       //  New starting time in seconds
  String s="v->{long t=System.nanoTime();t/=1e9;String s=%c%s%1$c;return t-%d>60?%1$cBOOM!%1$c:s.format(s,34,s,t);}";
                       //  Unformatted (quine) result-function
  return t-            //  If the difference between the new starting time
    70492.687613232    //  and hard-coded starting time from the main function
    >60?               //  is larger than the hard-coded integer from the main function
     "BOOM!"           //   Return "BOOM!"
    :                  //  Else:
     s.format(s,34,s,  //   Return the formatted (quine) result-function,
              t);}     //   with this new starting time as new hardcoded value

Deuxième programme de sortie:

Identique au premier programme de sortie, sauf qu'il 70492.687613232est remplacé par 70548.

Perl 5 + -p, 88 octets

$_="\$s=$_;\$t=$^T;".'$_=q{say$^T-$t<$s?qq{\$t=$^T;\$s=$s;\$_=q{$_};eval}:"BOOM!"};eval'

Les programmes de sortie doivent être exécutés avec -M5.010for say, mais pas -p.

Essayez-le en ligne!

05AB1E , 50 octets

"‘ÒÞ!""žažb‚žcª60β"D.VsI’"34ç ìD«ÿÿ©ÿDU-›iX®:ëÿ’D«

Peut certainement être joué un peu plus, mais il est assez difficile de produire un semi-quine qui génère un programme de quine avec des valeurs modifiées.

Essayez-le en ligne ou essayez un exemple de 20 secondes .

Explication:

"‘ÒÞ!"                     # Push the string "‘ÒÞ!"
"žažb‚žcª60β"              # Push the string "žažb‚žcª60β"
 D                         # Duplicate it
  .V                       # Execute it as 05AB1E code:
                           #  ža          : Push the current hours
                           #    žb        : Push the current minutes
                           #      ‚       : Pair them together
                           #       žcª    : Append the current seconds
                           #          60β : Convert from this integer list to base-60
s                          # Swap the seconds-integer and duplicated "žažb‚žcª60β"-string
I                          # Push the input
’"34ç ìD«ÿÿ©ÿDU-›iX®:ëÿ’  "# Push the string '"34ç ìD«ÿÿ©ÿDU-›iX®:ëÿ',
                           # where the `ÿ` are automatically replaced with the stack-values
 D«                        # Duplicate it, and append them together
                           # (after which the string is output implicitly as result)

Exemple de programme résultant:

"34ç ìD«30žažb‚žcª60β©35555DU-›iX®:ë‘ÒÞ!"34ç ìD«30žažb‚žcª60β©35555DU-›iX®:ë‘ÒÞ!

Ce qui est basé sur la Quine par défaut: "34çìD«"34çìD«.

"34ç ìD«30žažb‚žcª60β©35555DU-›iX®:ë‘ÒÞ!"
                           # Push this string
 34ç                       # Push 34, converted to a character: '"'
    ì                      # Prepend it in front of the string
     D«                    # Duplicate this string, and append them together
                           # (we now have the quine-string at the top of the stack)
  žažb‚žcª60β              # Get the current time in seconds similar as above
             ©             # Store it in variable `®` (without popping)
              35555        # Push the time this program was generated
                   DU      # Store a copy in variable `X`
                     -     # Subtract the two times
30                    ›i   # If the original input-integer is larger than this:
  X®:                      #  Replace integer `X` with `®` in the generated quine-string
                       ë   # Else:
  ‘ÒÞ!                     #  Push dictionary string "BOOM!"
                           # (and output the top of the stack implicitly as result)

Voir cette astuce de la mine de 05AB1E (section Comment utiliser le dictionnaire? ) Pour comprendre pourquoi ‘ÒÞ!est "BOOM!".
Remarque: la raison pour laquelle l'espace est là entre çìest parce que sinon, il est interprété comme une chaîne de dictionnaire ( triumph) en raison de la ’...’.