Desafio:

Crie um programa ou função que aceite uma entrada inteira, que emita um novo programa / função, conforme especificado abaixo.

Entrada:

Inteiro n: Tempo em segundos antes da bomba-relógio explodir.

Resultado:

O programa original que teve o tempo em segundos ncomo entrada, produzirá um novo programa / função que faz o seguinte:

• Os nsegundos se passaram desde que o programa anterior foi executado? ImpressãoBOOM!
• Senão: Imprima um programa / função que, quando executado, redefine o timer para nsegundos (e age da mesma forma que o primeiro programa / função emitido).

NOTA: Não é exatamente o mesmo que o primeiro programa / função emitido (pelo menos na maioria dos idiomas), porque o horário de início mudou (veja o exemplo de esclarecimento abaixo).

Exemplo de pseudocódigo:

Digamos que o programa original seja ABCe a entrada seja 60segundos:

ABCe 60saídas DEF(60).

• Se DEF(60)for executado dentro de 60 segundos, será exibido DEF_G(60), que age exatamente da mesma forma DEF(60), mas com uma nova hora de início.
• Se DEF(60)for executado após 60 segundos, será emitido BOOM!.

Exemplo de esclarecimento, o que quero dizer com 'horário de início':

1. O programa base com 60segundos de entrada é executado em 12:00:00. Emite o primeiro programa de saída com um horário de início de 12:00:00.
2. Este primeiro programa de saída com horário de início 12:00:00é executado em 12:00:45. Ele gera um segundo programa de saída com um horário de início de 12:00:45.
3. Este terceiro programa de saída com um horário de início 12:00:45é executado em 12:01:25. Ele gera um quarto programa de saída com um horário de início de 12:01:25.
4. Este quarto programa de saída com um horário de início 12:01:25é executado em 12:05:00. Ele irá produzir BOOM!.

Observe como a primeira saída seria impressa BOOM!depois 12:01:00, mas o programa de saída progrediu, mesmo estando 12:01:25na etapa 3, ele ainda emitirá o próximo programa em vez de BOOM!(porque os programas de saída de saída têm horários de início além do primeiro programa de saída) .

Regras do Desafio:

• Regras de quine padrão se aplicam.
• Pelo menos nsegundos deveriam ter passado. Portanto, se a entrada é 60e a hora de início foi 12:00:00, 12:01:00ela ainda emitirá o programa v2, mas 12:01:01será emitida BOOM!.
• Os programas de saída não receberão nenhuma entrada ( exceto um parâmetro vazio não utilizado, se for mais curto ). O horário de início deve ser atribuído aos próximos programas como valor 'codificado' (é por isso que a saída de um programa de saída não é exatamente a mesma que a anterior (na maioria dos idiomas).
• Somente o tamanho do seu programa / função principal é contado em termos de bytes.
• Você pode emitir o programa / função como string (ou formato razoável comparável, como byte / matriz de caracteres / lista), como função se o seu idioma suportar isso ou outros formatos razoáveis ​​(pergunte se você não tem certeza).

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

JavaScript, 51 bytes

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

Teste no navegador

versão antiga

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

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

Resposta antiga (retornar deve ser uma string)

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

Desculpe postar meu próprio desafio imediatamente. Pretende-se principalmente como um esclarecimento adicional do desafio, e eu estava duvidando de adicioná-lo à pergunta em si ou postá-lo como resposta (e decidi publicá-lo como uma resposta para não bagunçar o post do desafio).
E embora eu gostaria de dizer que também é algo para (tentar e) vencer, isso nem vale a pena mencionar porque, bem ... Java (quase) sempre é vencido. ; p

Experimente online.

Exemplo de saída:

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

Experimente a função lambda gerada aqui.

Exemplo de saída:

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

Explicação:

A função principal pega uma entrada inteira e retorna uma String. Basicamente, retorna uma função que é quine, com a entrada inteira e o tempo de início (em segundos como carimbo de data / hora) como valores codificados.

Função 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 foi usado nos exemplos abaixo:

Primeiro programa de saída:

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 saída:

O mesmo que o primeiro programa de saída, exceto que 70492.687613232é substituído por 70548.

Perl 5 + -p, 88 bytes

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

Os programas de saída devem ser executados com -M5.010for say, mas não -p.

Experimente online!

05AB1E , 50 bytes

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

Definitivamente, pode-se jogar um pouco mais, mas é bastante complicado produzir uma semiquina que produza um programa com valores modificados.

Experimente online ou tente uma execução de exemplo de 20 segundos .

Explicação:

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

Exemplo de programa resultante:

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

Que é baseado no Quine padrão: "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)

Veja esta dica 05AB1E meu (seção Como usar o dicionário? ) Para entender por que ‘ÒÞ!é "BOOM!".
NOTA: A razão pela qual o espaço existe çìé porque, caso contrário, ele é interpretado como uma string de dicionário ( triumph) devido ao ’...’.