Tantangan:

Buat program atau fungsi yang mengambil input integer, yang menampilkan program / fungsi baru seperti yang ditentukan di bawah ini.

Memasukkan:

Integer n: Waktu dalam detik sebelum Bom Waktu meledak.

Keluaran:

Program asli yang memiliki waktu dalam detik nsebagai input, akan menampilkan program / fungsi baru yang melakukan hal berikut:

• Sudah beberapa ndetik berlalu sejak program sebelumnya dijalankan? MencetakBOOM!
• Lain-lain: Cetak program / fungsi yang, ketika dijalankan dengan sendirinya, mengatur ulang timer ke ndetik (dan bertindak sama seperti program / fungsi yang pertama kali dikeluarkan).

CATATAN: Ini tidak persis sama dengan program / fungsi keluaran pertama (dalam kebanyakan bahasa setidaknya), karena waktu mulai telah berubah (lihat contoh klarifikasi di bawah).

Contoh kode semu:

Katakanlah program aslinya ABCdan inputnya adalah 60detik:

ABC& 60keluaran DEF(60).

• Jika DEF(60)dijalankan dalam 60 detik, itu akan menghasilkan DEF_G(60), yang bertindak persis sama DEF(60), tetapi dengan waktu mulai yang baru.
• Jika DEF(60)dijalankan setelah 60 detik, itu akan ditampilkan BOOM!.

Contoh klarifikasi yang saya maksud dengan 'waktu mulai':

1. Program dasar dengan input 60detik dijalankan pada 12:00:00. Ini output program output pertama dengan waktu mulai 12:00:00.
2. Program keluaran pertama ini dengan waktu mulai 12:00:00dijalankan pada 12:00:45. Ini mengeluarkan program keluaran kedua dengan waktu mulai 12:00:45.
3. Program keluaran ketiga ini dengan waktu mulai 12:00:45dijalankan pada 12:01:25. Ini mengeluarkan program keluaran keempat dengan waktu mulai 12:01:25.
4. Program keluaran keempat ini dengan waktu mulai 12:01:25dijalankan pada 12:05:00. Ini akan menampilkan BOOM!.

Perhatikan bagaimana output pertama akan dicetak BOOM!setelahnya 12:01:00, tetapi program output telah berkembang sehingga meskipun 12:01:25pada langkah 3, itu masih akan menampilkan program berikutnya sebagai gantinya BOOM!(karena program output-of-output telah memulai waktu di luar program output pertama) .

Aturan Tantangan:

• Aturan quine default berlaku.
• Setidaknya ndetik harus berlalu. Jadi jika inputnya 60dan waktu mulai adalah 12:00:00, pada saat 12:01:00itu masih akan menampilkan program v2, tetapi pada saat 12:01:01itu akan menampilkan BOOM!.
• Program output tidak akan mengambil input apa pun ( kecuali untuk parameter kosong yang tidak digunakan jika lebih pendek ). Waktu mulai harus diberikan ke program berikutnya sebagai nilai 'hard-coded' (itulah sebabnya output dari program output tidak persis sama dengan yang sebelumnya (dalam kebanyakan bahasa).
• Hanya ukuran program / fungsi utama Anda yang dihitung dalam satuan byte.
• Anda dapat menampilkan program / fungsi baik sebagai string (atau format wajar yang sebanding, seperti byte / array karakter / daftar), sebagai fungsi jika bahasa Anda mendukung ini, atau format wajar lainnya (tanyakan apakah Anda tidak yakin).

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda, jadi Anda diperbolehkan menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda.
• Juga, silakan tambahkan penjelasan jika perlu.

JavaScript, 51 byte

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

Tes di browser

versi lama

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

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

Jawaban lama (kembali harus berupa string)

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

Maaf memposting tantangan saya sendiri segera. Ini terutama dimaksudkan sebagai klarifikasi lebih lanjut dari tantangan, dan saya ragu apakah akan menambahkannya ke pertanyaan itu sendiri atau mempostingnya sebagai jawaban (dan memutuskan untuk mempostingnya sebagai jawaban untuk tidak mengacaukan posting tantangan).
Dan meskipun saya ingin mengatakan itu juga sesuatu untuk (mencoba dan) mengalahkan, itu bahkan tidak layak disebutkan karena, well .. Java (hampir) selalu dikalahkan. ; p

Cobalah online.

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

Coba fungsi lambda yang dikeluarkan di sini.

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

Penjelasan:

Fungsi utama mengambil input integer dan mengembalikan sebuah String. Ini pada dasarnya mengembalikan fungsi yang merupakan quine, dengan input integer dan waktu mulai (dalam detik sebagai timestamp) sebagai nilai hard-coded.

Fungsi utama:

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 digunakan dalam contoh di bawah ini:

Program keluaran pertama:

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

Program keluaran kedua:

Sama seperti program keluaran pertama, kecuali yang 70492.687613232diganti dengan 70548.

Perl 5 + -p, 88 byte

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

Program output harus dijalankan dengan -M5.010untuk say, tetapi tidak -p.

Cobalah online!

05AB1E , 50 byte

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

Pasti bisa bermain golf sedikit lebih, tapi cukup sulit untuk menghasilkan semi-quine yang menghasilkan program-quine dengan nilai yang dimodifikasi.

Cobalah online atau coba jalankan contoh 20 detik .

Penjelasan:

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

Contoh program yang dihasilkan:

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

Yang didasarkan pada 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)

Lihat ini ujung 05AB1E saya (bagian Cara menggunakan kamus? ) Untuk memahami mengapa ‘ÒÞ!adalah "BOOM!".
CATATAN: Alasan spasi di sana çìadalah karena jika tidak itu menafsirkan sebagai kamus-string ( triumph) karena ’...’.