Thử thách:

Tạo một chương trình hoặc hàm lấy đầu vào số nguyên, đầu ra một chương trình / hàm mới như được chỉ định bên dưới.

Đầu vào:

Số nguyên n: Thời gian tính bằng giây trước khi Bom Thời gian phát nổ.

Đầu ra:

Chương trình ban đầu có thời gian tính bằng giây nlà đầu vào, sẽ xuất ra một chương trình / chức năng mới thực hiện như sau:

• Đã nvài giây trôi qua kể từ khi chương trình trước được chạy? InBOOM!
• Khác: In một chương trình / chức năng, khi tự chạy, đặt lại bộ hẹn giờ trở lại ngiây (và hoạt động giống như chương trình / chức năng được xuất ra đầu tiên).

LƯU Ý: Nó không hoàn toàn giống với chương trình / chức năng được xuất ra đầu tiên (ít nhất là trong hầu hết các ngôn ngữ), vì thời gian bắt đầu đã thay đổi (xem ví dụ làm rõ bên dưới).

Ví dụ mã giả:

Giả sử chương trình gốc là ABCvà đầu vào là 60giây:

ABC& 60đầu ra DEF(60).

• Nếu DEF(60)được chạy trong vòng 60 giây, nó sẽ xuất ra DEF_G(60), hoạt động giống hệt như DEF(60), nhưng với thời gian bắt đầu mới.
• Nếu DEF(60)được chạy sau 60 giây, nó sẽ xuất ra BOOM!.

Ví dụ làm rõ ý tôi muốn nói với 'thời gian bắt đầu':

1. Chương trình cơ sở với 60giây đầu vào được chạy tại 12:00:00. Nó xuất chương trình đầu ra đầu tiên với thời gian bắt đầu là 12:00:00.
2. Chương trình đầu ra đầu tiên này với thời gian bắt đầu 12:00:00được chạy tại 12:00:45. Nó xuất ra một chương trình đầu ra thứ hai với thời gian bắt đầu là 12:00:45.
3. Chương trình đầu ra thứ ba này với thời gian bắt đầu 12:00:45được chạy tại 12:01:25. Nó xuất ra một chương trình đầu ra thứ tư với thời gian bắt đầu là 12:01:25.
4. Chương trình đầu ra thứ tư này với thời gian bắt đầu 12:01:25được chạy tại 12:05:00. Nó sẽ xuất ra BOOM!.

Lưu ý cách đầu ra đầu tiên sẽ in BOOM!sau đó 12:01:00, nhưng chương trình đầu ra đã tiến triển như vậy mặc dù 12:01:25ở bước 3, nó vẫn sẽ xuất chương trình tiếp theo thay vì BOOM!(vì các chương trình đầu ra có thời gian bắt đầu vượt quá chương trình đầu ra đầu tiên đó) .

Quy tắc thử thách:

• Quy tắc quine mặc định áp dụng.
• Ít nhất nvài giây đã trôi qua. Vì vậy, nếu đầu vào là 60và thời gian bắt đầu 12:00:00, tại 12:01:00nó vẫn sẽ xuất chương trình v2, nhưng tại 12:01:01đó sẽ xuất ra BOOM!.
• Các chương trình đầu ra sẽ không nhận bất kỳ đầu vào nào ( ngoại trừ một tham số không sử dụng trống nếu nó ngắn hơn ). Thời gian bắt đầu phải được trao cho các chương trình tiếp theo dưới dạng giá trị 'được mã hóa cứng' (đó là lý do tại sao đầu ra của chương trình đầu ra không giống hệt như trước đó (trong hầu hết các ngôn ngữ).
• Chỉ kích thước của chương trình / chức năng chính của bạn được tính theo byte.
• Bạn có thể xuất chương trình / hàm dưới dạng chuỗi (hoặc định dạng hợp lý có thể so sánh, như byte / mảng ký tự / danh sách), dưới dạng hàm nếu ngôn ngữ của bạn hỗ trợ điều này hoặc các định dạng hợp lý khác (vui lòng hỏi nếu bạn không chắc chắn).

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Các quy tắc chuẩn áp dụng cho câu trả lời của bạn, vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, các chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn.
• Ngoài ra, xin vui lòng thêm một lời giải thích nếu cần thiết.

JavaScript, 51 byte

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

Kiểm tra trong trình duyệt

phiên bản cũ

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

Kiểm tra trong trình duyệt

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

Câu trả lời cũ (trả về phải là một chuỗi)

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

Xin lỗi để gửi thử thách của riêng tôi ngay lập tức. Nó chủ yếu có nghĩa là làm rõ thêm về thách thức, và tôi đã nghi ngờ không biết nên thêm nó vào câu hỏi hay đăng nó như một câu trả lời (và quyết định đăng nó như một câu trả lời để không làm lộn xộn bài thách thức).
Và mặc dù tôi muốn nói rằng đó cũng là thứ để (thử và) đánh bại, điều đó thậm chí không đáng nhắc đến bởi vì, ừm .. Java (hầu như) luôn bị đánh bại. ; p

Hãy thử trực tuyến.

Ví dụ đầu ra:

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

Hãy thử chức năng lambda xuất ra ở đây.

Ví dụ đầu ra:

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

Giải trình:

Hàm main nhận một đầu vào số nguyên và trả về một Chuỗi. Về cơ bản, nó trả về một hàm là một quine, với đầu vào số nguyên và thời gian bắt đầu (tính bằng giây là dấu thời gian) dưới dạng các giá trị được mã hóa cứng.

Chức năng chính:

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 đã được sử dụng trong các ví dụ dưới đây:

Chương trình đầu ra:

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

Chương trình đầu ra thứ hai:

Giống như chương trình đầu ra đầu tiên, ngoại trừ 70492.687613232được thay thế bằng 70548.

Perl 5 + -p, 88 byte

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

Chương trình đầu ra phải được chạy với -M5.010cho say, nhưng không phải -p.

Hãy thử trực tuyến!

05AB1E , 50 byte

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

Chắc chắn có thể chơi gôn nhiều hơn một chút, nhưng thật khó để tạo ra một nửa bán dẫn tạo ra một chương trình quine với các giá trị được sửa đổi.

Hãy thử trực tuyến hoặc thử chạy ví dụ 20 giây .

Giải trình:

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

Ví dụ chương trình kết quả:

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

Mà dựa trên quine mặc định : "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)

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) Để hiểu tại sao ‘ÒÞ!là "BOOM!".
LƯU Ý: Lý do không gian ở giữa çìlà vì nếu không, nó diễn giải dưới dạng chuỗi từ điển ( triumph) do ’...’.