Herausforderung:

Erstellen Sie ein Programm oder eine Funktion, die eine ganzzahlige Eingabe akzeptiert und ein neues Programm / eine neue Funktion wie unten angegeben ausgibt.

Eingang:

Ganzzahl n: Zeit in Sekunden, bevor die Zeitbombe explodiert.

Ausgabe:

Das ursprüngliche Programm, das die Zeit in Sekunden nals Eingabe hatte, gibt ein neues Programm / eine neue Funktion aus, die Folgendes ausführt:

• Sind nSekunden vergangen, seit das vorherige Programm ausgeführt wurde? DruckenBOOM!
• Sonst: Drucken Sie ein Programm / eine Funktion, die, wenn sie selbst ausgeführt wird, den Timer auf nSekunden zurücksetzt (und sich wie das erste ausgegebene Programm / die erste ausgegebene Funktion verhält).

HINWEIS: Es ist nicht genau dasselbe wie das erste ausgegebene Programm / die erste ausgegebene Funktion (zumindest in den meisten Sprachen), da sich die Startzeit geändert hat (siehe Erläuterungsbeispiel unten).

Pseudocode Beispiel:

Angenommen, das ursprüngliche Programm ist ABCund die Eingabe ist 60Sekunden:

ABC& 60Ausgänge DEF(60).

• Wenn DEF(60)es innerhalb von 60 Sekunden ausgeführt wird, wird es ausgegeben DEF_G(60), was genau so funktioniert DEF(60), jedoch mit einer neuen Startzeit.
• Wenn DEF(60)es nach 60 Sekunden ausgeführt wird, wird es ausgegeben BOOM!.

Klärungsbeispiel, was ich mit "Startzeit" meine:

1. Das Basisprogramm mit den eingegebenen 60Sekunden wird um ausgeführt 12:00:00. Es gibt das erste Ausgabeprogramm mit einer Startzeit von aus 12:00:00.
2. Dieses erste Ausgabeprogramm mit Startzeit von 12:00:00wird um ausgeführt 12:00:45. Es gibt ein zweites Ausgabeprogramm mit einer Startzeit von aus 12:00:45.
3. Dieses dritte Ausgabeprogramm mit einer Startzeit von 12:00:45wird ausgeführt 12:01:25. Es gibt ein viertes Ausgabeprogramm mit einer Startzeit von aus 12:01:25.
4. Dieses vierte Ausgabeprogramm mit einer Startzeit von 12:01:25wird ausgeführt 12:05:00. Es wird ausgegeben BOOM!.

Beachten Sie, wie der erste Ausgang würde Druck BOOM!nach 12:01:00, aber das Ausgabeprogramm so auch Fortschritte gemacht hat , obwohl es 12:01:25in Schritt 3, wird es noch geben das nächste Programm statt BOOM!(weil die Ausgangs-of-Ausgabeprogramme hat mal über diese erste Ausgabe Programmstart) .

Herausforderungsregeln:

• Es gelten die Standardregeln für Quine.
• Es sollten mindestens nSekunden vergangen sein. Wenn also die Eingabe ist 60und die Startzeit war 12:00:00, 12:01:00wird das v2-Programm weiterhin ausgegeben, aber 12:01:01ausgegeben BOOM!.
• Die Ausgabeprogramme nehmen keine Eingabe entgegen ( außer einem leeren, nicht verwendeten Parameter, wenn dieser kürzer ist ). Die Startzeit sollte für die nächsten Programme als "fest codierter" Wert angegeben werden (weshalb die Ausgabe eines Ausgabeprogramms nicht genau mit der vorherigen übereinstimmt (in den meisten Sprachen).
• Nur die Größe Ihres Hauptprogramms / Ihrer Hauptfunktion wird in Bytes gezählt.
• Sie können das Programm / die Funktion entweder als Zeichenfolge (oder als vergleichbares vernünftiges Format wie Byte / Zeichenarray / Liste), als Funktion, wenn Ihre Sprache dies unterstützt, oder als andere vernünftige Formate ausgeben (bitte fragen Sie, wenn Sie sich nicht sicher sind).

Allgemeine Regeln:

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln , sodass Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden dürfen. Ihr Anruf.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie bei Bedarf auch eine Erklärung hinzu.

JavaScript, 51 Bytes

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

Im Browser testen

alte Version

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

Im Browser testen

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

Alte Antwort (Rückgabe sollte eine Zeichenfolge sein)

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

Es tut mir leid, meine eigene Herausforderung sofort zu posten. Es ist hauptsächlich als weitere Klarstellung der Herausforderung gedacht, und ich bezweifelte, ob ich es der Frage selbst hinzufügen oder als Antwort veröffentlichen sollte (und entschied mich, es als Antwort zu veröffentlichen, um den Herausforderungsbeitrag nicht zu überladen).
Und obwohl ich sagen möchte, dass es auch etwas zu (versuchen und) zu schlagen ist, ist das nicht einmal erwähnenswert, weil Java (fast) immer geschlagen wird. ; p

Probieren Sie es online aus.

Beispielausgabe:

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

Probieren Sie hier die ausgegebene Lambda-Funktion aus.

Beispielausgabe:

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

Erläuterung:

Die Hauptfunktion nimmt eine Ganzzahl-Eingabe und gibt einen String zurück. Grundsätzlich wird eine Funktion zurückgegeben, bei der es sich um eine Quine handelt, bei der die Ganzzahl eingegeben und die Startzeit (in Sekunden als Zeitstempel) als fest codierte Werte angegeben werden.

Hauptfunktion:

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 wurde in den folgenden Beispielen verwendet:

Erstes Ausgabeprogramm:

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

Zweites Ausgabeprogramm:

Das gleiche wie das erste Ausgabeprogramm, außer dass 70492.687613232es durch ersetzt wird 70548.

Perl 5 + -p, 88 Bytes

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

Ausgabeprogramme müssen mit -M5.010for ausgeführt werden say, jedoch nicht -p.

Probieren Sie es online aus!

05AB1E , 50 Bytes

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

Kann definitiv ein bisschen mehr Golf gespielt werden, aber es ist ziemlich schwierig, ein Semi-Quine auszugeben, das ein Quine-Programm mit modifizierten Werten ausgibt.

Probieren Sie es online aus oder versuchen Sie es mit einem 20-Sekunden-Beispiellauf .

Erläuterung:

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

Beispiel resultierendes Programm:

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

Welches basiert auf dem Standard Quine : "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)

Sehen Sie diese 05AB1E Spitze von mir (Abschnitt Wie das Wörterbuch benutzen? ) Zu verstehen , warum ‘ÒÞ!ist "BOOM!".
HINWEIS: Der Grund, warum das Leerzeichen dazwischen steht, çìliegt darin, dass es triumphaufgrund des ’...’.