Wyzwanie:

Utwórz program lub funkcję, która pobierze liczbę całkowitą, która wyprowadza nowy program / funkcję, jak określono poniżej.

Wejście:

Liczba całkowita n: czas w sekundach przed wybuchem bomby zegarowej.

Wynik:

Oryginalny program, który jako czas wprowadził czas w sekundach n, wyświetli nowy program / funkcję, która wykonuje następujące czynności:

• Czy nminęły sekundy od uruchomienia poprzedniego programu? WydrukowaćBOOM!
• W przeciwnym razie: Wydrukuj program / funkcję, która po uruchomieniu zresetuje licznik z powrotem do nsekund (i działa tak samo jak pierwszy program / funkcja, która została uruchomiona ).

UWAGA: Nie jest dokładnie taki sam jak pierwszy wyprowadzony program / funkcja (przynajmniej w większości języków), ponieważ zmienił się czas rozpoczęcia (patrz przykład wyjaśnienia poniżej).

Przykład pseudokodu:

Powiedzmy, że oryginalny program jest, ABCa dane wejściowe to 60sekundy:

ABCi 60wyjścia DEF(60).

• Jeśli DEF(60)zostanie uruchomiony w ciągu 60 sekund, zostanie wygenerowany sygnał wyjściowy DEF_G(60), który działa dokładnie tak samo jak DEF(60), ale z nowym czasem rozpoczęcia.
• Jeśli DEF(60)zostanie uruchomiony po 60 sekundach, zostanie wyprowadzony BOOM!.

Przykład wyjaśnienia, co mam na myśli przez „czas rozpoczęcia”:

1. Program podstawowy z 60sekundami wprowadzania jest uruchamiany w 12:00:00. Wysyła pierwszy program wyjściowy z czasem rozpoczęcia wynoszącym 12:00:00.
2. Ten pierwszy program wyjściowy z czasem rozpoczęcia 12:00:00jest uruchamiany o godzinie 12:00:45. Wysyła drugi program wyjściowy z czasem rozpoczęcia wynoszącym 12:00:45.
3. Ten trzeci program wyjściowy z czasem rozpoczęcia 12:00:45jest uruchamiany o godzinie 12:01:25. Wysyła czwarty program wyjściowy z czasem rozpoczęcia wynoszącym 12:01:25.
4. Czwarty program wyjściowy z czasem rozpoczęcia 12:01:25jest uruchamiany o godzinie 12:05:00. Wyjdzie BOOM!.

Uwaga jak pierwsze wyjście byłoby wydrukować BOOM!po 12:01:00, ale program wyjście postępuje tak, mimo że 12:01:25w punkcie 3, to będzie jeszcze wyjście następny program zamiast BOOM!(bo wyjście-of-wyjścia programów został razy poza tym pierwszym programie wyjściowego wyjściowy) .

Zasady konkursu:

• Obowiązują domyślne zasady quine.
• nPowinny minąć przynajmniej sekundy. Więc jeśli wejście jest 60i czas rozpoczęcia był 12:00:00, 12:01:00to nadal będzie wypisywać program v2, ale przy 12:01:01nim będzie wypisywać BOOM!.
• Programy wyjściowe nie przyjmą żadnych danych wejściowych ( z wyjątkiem pustego, nieużywanego parametru, jeśli jest krótszy ). Czas rozpoczęcia należy podawać kolejnym programom jako wartość „zakodowaną na stałe” (dlatego wyjście programu wyjściowego nie jest dokładnie takie samo jak poprzednie (w większości języków).
• Tylko rozmiar głównego programu / funkcji jest liczony w bajtach.
• Możesz wyprowadzić program / funkcję jako ciąg znaków (lub porównywalny rozsądny format, taki jak bajt / tablica znaków / lista), jako funkcję, jeśli Twój język to obsługuje, lub inne rozsądne formaty (zapytaj, jeśli nie jesteś pewien).

Główne zasady:

• To jest golf-golf, więc najkrótsza odpowiedź w bajtach wygrywa.
  Nie pozwól, aby języki code-golf zniechęciły Cię do publikowania odpowiedzi w językach innych niż kodowanie Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

JavaScript, 51 bajtów

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

Przetestuj w przeglądarce

stara wersja

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

Przetestuj w przeglądarce

JavaScript, 53 bajty

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

Stara odpowiedź (zwracany powinien być ciąg znaków)

JavaScript, 78 bajtów

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

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

Przepraszam, że od razu opublikowałem własne wyzwanie. Ma to głównie na celu wyjaśnienie wyzwania i zastanawiałem się, czy dodać je do samego pytania, czy opublikować jako odpowiedź (i postanowiłem opublikować je jako odpowiedź, aby nie zagracać postu z wyzwaniem).
I chociaż chciałbym powiedzieć, że jest to także coś do (próbowania) bicia, nie warto nawet o tym wspominać, ponieważ ... cóż ... Java (prawie) zawsze zostaje pobita. ; p

Wypróbuj online.

Przykładowe dane wyjściowe:

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

Wypróbuj tutaj wyprowadzoną funkcję lambda.

Przykładowe dane wyjściowe:

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

Wyjaśnienie:

Główna funkcja przyjmuje liczbę całkowitą i zwraca ciąg znaków. Zasadniczo zwraca funkcję, która jest quine, z liczbą całkowitą i czasem rozpoczęcia (w sekundach jako znacznik czasu) jako wartości zakodowane na stałe.

Główna funkcja:

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 zastosowano w poniższych przykładach:

Pierwszy program wyjściowy:

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

Drugi program wyjściowy:

To samo co pierwszy program wyjściowy, tyle że 70492.687613232zastąpiony przez 70548.

Perl 5 + -p, 88 bajtów

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

Programy wyjściowe muszą być uruchamiane -M5.010dla say, ale nie dla -p.

Wypróbuj online!

05AB1E , 50 bajtów

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

Można zdecydowanie zagrać w golfa nieco więcej, ale dość trudne jest wyprowadzenie pół-quine, która wyprowadza program quine ze zmodyfikowanymi wartościami.

Wypróbuj online lub spróbuj uruchomić 20-sekundowy przykład .

Wyjaśnienie:

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

Przykład wynikowego programu:

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

Który jest oparty na domyślnym Quine'a: "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)

Zobacz moją wskazówkę 05AB1E (sekcja Jak korzystać ze słownika? ), Aby zrozumieć, dlaczego tak ‘ÒÞ!jest "BOOM!".
UWAGA: Powodem, dla którego odstęp między nimi çìjest, jest to, że w przeciwnym razie jest interpretowany jako słownik-ciąg ( triumph) z powodu ’...’.