Desafío:

Cree un programa o función que tome una entrada entera, que genere un nuevo programa / función como se especifica a continuación.

Entrada:

Entero n: tiempo en segundos antes de que explote la bomba de tiempo.

Salida:

El programa original que tenía el tiempo en segundos ncomo entrada, generará un nuevo programa / función que hace lo siguiente:

• ¿ nHan pasado segundos desde que se ejecutó el programa anterior? ImpresiónBOOM!
• De lo contrario: imprima un programa / función que, cuando se ejecuta, restablece el temporizador a nsegundos (y actúa igual que el primer programa / función emitido).

NOTA: No es exactamente lo mismo que el primer programa / función de salida (al menos en la mayoría de los idiomas), porque la hora de inicio ha cambiado (consulte el ejemplo de aclaración a continuación).

Ejemplo de pseudocódigo:

Digamos que el programa original es ABCy la entrada es 60segundos:

ABCy 60salidas DEF(60).

• Si DEF(60)se ejecuta dentro de los 60 segundos, saldrá DEF_G(60), que actúa exactamente igual DEF(60), pero con un nuevo tiempo de inicio.
• Si DEF(60)se ejecuta después de 60 segundos, saldrá BOOM!.

Ejemplo de aclaración a lo que me refiero con 'hora de inicio':

1. El programa base con 60segundos de entrada se ejecuta en 12:00:00. Emite el primer programa de salida con un tiempo de inicio de 12:00:00.
2. Este primer programa de salida con hora de inicio 12:00:00se ejecuta en 12:00:45. Produce un segundo programa de salida con un tiempo de inicio de 12:00:45.
3. Este tercer programa de salida con un tiempo de inicio 12:00:45se ejecuta en 12:01:25. Produce un cuarto programa de salida con un tiempo de inicio de 12:01:25.
4. Este cuarto programa de salida con un tiempo de inicio 12:01:25se ejecuta en 12:05:00. Es la salida BOOM!.

Tenga en cuenta cómo se imprimirá la primera salida BOOM!después 12:01:00, pero el programa de salida ha progresado, por lo que a pesar de que está 12:01:25en el paso 3, seguirá emitiendo el siguiente programa en lugar de BOOM!(porque los programas de salida de salida tienen tiempos de inicio más allá de ese primer programa de salida) .

Reglas de desafío:

• Se aplican las reglas predeterminadas de quine.
• Al menos nsegundos deberían haber pasado. Entonces, si la entrada es 60y el tiempo de inicio fue 12:00:00, 12:01:00todavía emitirá el programa v2, pero a 12:01:01la salida BOOM!.
• Los programas de salida no tomarán ninguna entrada ( excepto un parámetro vacío no utilizado si es más corto ). El tiempo de inicio se debe dar a los siguientes programas como valor 'codificado' (por lo que la salida de un programa de salida no es exactamente la misma que la anterior (en la mayoría de los idiomas).
• Solo el tamaño de su programa / función principal se cuenta en términos de bytes.
• Puede generar el programa / función como cadena (o formato razonable comparable, como byte / matriz de caracteres / lista), como función si su idioma admite este u otros formatos razonables (pregunte si no está seguro).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

JavaScript, 51 bytes

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

Prueba en navegador

versión antigua

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

Prueba en navegador

JavaScript, 53 bytes

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

Respuesta anterior (el regreso debe ser una cadena)

JavaScript, 78 bytes

(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 bytes

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

Lamento publicar mi propio desafío de inmediato. Se entiende principalmente como una aclaración adicional del desafío, y dudaba si agregarlo a la pregunta en sí o publicarlo como respuesta (y decidí publicarlo como una respuesta para no saturar la publicación del desafío).
Y aunque me gustaría decir que también es algo para (intentar y) vencer, eso ni siquiera vale la pena mencionar porque, bueno ... Java (casi) siempre es golpeado. ;pags

Pruébalo en línea.

Salida de ejemplo:

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

Pruebe la función lambda de salida aquí.

Salida de ejemplo:

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

Explicación:

La función principal toma una entrada entera y devuelve una cadena. Básicamente, devuelve una función que es una quine, con la entrada entera y el tiempo de inicio (en segundos como marca de tiempo) como valores codificados.

Función principal:

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 se utilizó en los siguientes ejemplos:

Primer programa de salida:

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

Segundo programa de salida:

Lo mismo que el primer programa de salida, excepto que 70492.687613232se reemplaza con 70548.

Perl 5 + -p, 88 bytes

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

Los programas de salida deben ejecutarse con -M5.010for say, pero no con -p.

Pruébalo en línea!

05AB1E , 50 bytes

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

Definitivamente se puede jugar un poco más, pero es bastante complicado generar un semi-quine que genera un programa de quine con valores modificados.

Pruébelo en línea o pruebe con una ejecución de ejemplo de 20 segundos .

Explicación:

"‘ÒÞ!"                     # 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)

Programa resultante de ejemplo:

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

Que se basa en la quine por defecto: "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)

Ver este consejo 05AB1E mío (sección Cómo usar el diccionario? ) Para entender por qué ‘ÒÞ!es "BOOM!".
NOTA: La razón por la que el espacio está allí çìes porque, de lo contrario, se interpreta como una cadena de diccionario ( triumph) debido a ’...’.