Sfida:

Creare un programma o una funzione che accetta un input intero, che genera un nuovo programma / funzione come specificato di seguito.

Ingresso:

Numero intero n: tempo in secondi prima dell'esplosione della bomba a orologeria.

Produzione:

Il programma originale che aveva il tempo in secondi ncome input, produrrà un nuovo programma / funzione che procede come segue:

• Sono ntrascorsi secondi dall'esecuzione del programma precedente? StampaBOOM!
• Altrimenti: stampa un programma / funzione che, una volta eseguito, reimposta il timer sui nsecondi (e si comporta come il primo programma / funzione emesso).

NOTA: non è esattamente lo stesso del primo programma / funzione emesso (almeno nella maggior parte delle lingue), poiché l'ora di inizio è cambiata (vedere l'esempio di chiarimento di seguito).

Esempio di pseudo-codice:

Diciamo che il programma originale è ABCe l'input è 60secondi:

ABCe 60uscite DEF(60).

• Se DEF(60)viene eseguito entro 60 secondi, verrà emesso DEF_G(60), che si comporta esattamente come DEF(60), ma con un nuovo orario di inizio.
• Se DEF(60)viene eseguito dopo 60 secondi, verrà emesso BOOM!.

Esempio di chiarimento sul significato di "ora di inizio":

1. Il programma di base con i 60secondi di input viene eseguito alle 12:00:00. Emette il primo programma di output con un tempo di inizio di 12:00:00.
2. Questo primo programma di output con l'ora di inizio di 12:00:00viene eseguito alle 12:00:45. Emette un secondo programma di output con un tempo di inizio di 12:00:45.
3. Questo terzo programma di output con un orario di inizio di 12:00:45viene eseguito alle 12:01:25. Emette un quarto programma di output con un tempo di inizio di 12:01:25.
4. Questo quarto programma di output con un orario di inizio di 12:01:25viene eseguito alle 12:05:00. Verrà emesso BOOM!.

Nota come verrà stampato il primo output BOOM!dopo 12:01:00, ma il programma di output è progredito, quindi anche se è 12:01:25al passaggio 3, verrà comunque emesso il programma successivo anziché BOOM!(poiché i programmi di output di output hanno tempi di avvio oltre quel primo programma di output) .

Regole della sfida:

• Si applicano le regole Quine predefinite.
• Almeno nsecondi dovrebbero essere passati. Quindi, se l'input è 60e l'ora di inizio era 12:00:00, 12:01:00verrà comunque emesso il programma v2, ma 12:01:01verrà emesso BOOM!.
• I programmi di output non prenderanno alcun input ( tranne per un parametro vuoto inutilizzato se è più breve ). L'ora di inizio dovrebbe essere data ai programmi successivi come valore "hardcoded" (motivo per cui l'output di un programma di output non è esattamente uguale al precedente (nella maggior parte delle lingue).
• Viene calcolata solo la dimensione del programma / funzione principale in termini di byte.
• Puoi generare il programma / funzione come stringa (o formato ragionevole comparabile, come array / elenco di byte / caratteri), come funzione se la tua lingua supporta questo o altri formati ragionevoli (chiedi se non sei sicuro).

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link con un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

JavaScript, 51 byte

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

Test nel browser

vecchia versione

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

Test nel browser

JavaScript, 53 byte

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

Vecchia risposta (il ritorno dovrebbe essere una stringa)

JavaScript, 78 byte

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

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

Mi dispiace pubblicare subito la mia sfida. È principalmente inteso come ulteriore chiarimento della sfida, e dubitavo che fosse necessario aggiungerla alla domanda stessa o pubblicarla come risposta (e ho deciso di pubblicarla come risposta per non ingombrare il post della sfida).
E anche se vorrei dire che è anche qualcosa da (provare e) battere, non vale nemmeno la pena menzionarlo perché, beh ... Java (quasi) viene sempre battuto. ; p

Provalo online.

Esempio di output:

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

Prova qui la funzione lambda emessa.

Esempio di output:

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

Spiegazione:

La funzione principale accetta un input intero e restituisce una stringa. In sostanza restituisce una funzione che è un quine, con l'input intero e l'ora di inizio (in secondi come data / ora) come valori codificati.

Funzione 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 è stato utilizzato negli esempi seguenti:

Primo programma di output:

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

Secondo programma di output:

Lo stesso del primo programma di output, tranne che 70492.687613232è sostituito da 70548.

Perl 5+ -p, 88 byte

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

I programmi di output devono essere eseguiti con -M5.010for say, ma non -p.

Provalo online!

05AB1E , 50 byte

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

Può sicuramente giocare a golf un po 'di più, ma è piuttosto difficile produrre un semi-quine che produce un programma di quine con valori modificati.

Provalo online o prova una corsa di esempio di 20 secondi .

Spiegazione:

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

Esempio di programma risultante:

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

Che si basa sulla Quine default: "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)

Vedere questo suggerimento 05AB1E mio (sezione Come utilizzare il dizionario? ) Per capire il motivo per cui ‘ÒÞ!è "BOOM!".
NOTA: il motivo per cui lo spazio è presente çìè perché altrimenti è interpretato come una stringa di dizionario ( triumph) a causa di ’...’.