挑战：

创建一个采用整数输入的程序或函数，该程序或函数输出一个新的程序/函数，如下所示。

输入：

整数n：时间炸弹爆炸前的时间（以秒为单位）。

输出：

以秒n为单位的时间输入的原始程序将输出执行以下操作的新程序/功能：

• 已经n过去了秒自上次程序运行？打印BOOM!
• 否则：打印一个程序/函数，该程序/函数在自身运行时将计时器重置为n秒（并且与第一个输出的程序/函数相同）。

注意：它与第一个输出的程序/函数不完全相同（至少在大多数语言中是这样），因为开始时间已更改（请参见下面的说明示例）。

伪代码示例：

假设原始程序是ABC，输入是60秒：

ABC＆60输出DEF(60)。

• 如果DEF(60)在60秒内运行，它将输出DEF_G(60)，其作用与DEF(60)，但是具有新的开始时间。
• 如果DEF(60)在60秒后运行，它将输出BOOM!。

澄清示例“开始时间”的含义：

1. 输入60秒的基本程序在处运行12:00:00。它以开始时间输出第一个输出程序12:00:00。
2. 开始时间为的第一个输出程序在12:00:00处运行12:00:45。它以开始时间输出第二个输出程序12:00:45。
3. 开始时间为的第三个输出程序在12:00:45处运行12:01:25。它输出开始时间为的第四输出程序12:01:25。
4. 开始时间为的第四个输出程序在12:01:25处运行12:05:00。它将输出BOOM!。

请注意，第一个输出将BOOM!在之后输出12:01:00，但是输出程序已进行，因此即使12:01:25在第3步，它仍将输出下一个程序，而不是输出BOOM!（因为输出程序的开始时间超过了第一个输出程序） 。

挑战规则：

• 默认的规则是规则。
• 至少n应该过去几秒钟。因此，如果输入为60，开始时间为12:00:00，12:01:00则仍然会输出v2程序，但12:01:01会输出BOOM!。
• 输出程序将不接受任何输入（除了较短的空未使用参数外）。开始时间应以“硬编码”值的形式提供给下一个程序（这就是为什么输出程序的输出与前一个程序（在大多数语言中）不完全相同的原因。
• 仅以字节为单位计算主程序/功能的大小。
• 您可以将程序/函数输出为字符串（或相当合理的格式，例如字节/字符数组/列表），如果您的语言支持，则输出为函数，也可以输出其他合理格式（请询问您是否不确定）。

通用规则：

• 这是 代码高尔夫球，因此以字节为单位的最短答案会获胜。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于您的答案，因此您可以使用STDIN / STDOUT，具有正确参数的函数/方法和返回类型的完整程序。您的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如有必要，请添加说明。

JavaScript，51个字节

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

在浏览器中测试

旧版

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

在浏览器中测试

JavaScript，53个字节

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

旧答案（返回应为字符串）

JavaScript，78个字节

(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字节

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

抱歉，请立即发布我自己的挑战。它主要是为了进一步澄清挑战，我怀疑是将其添加到问题本身还是作为答案发布（并决定将其发布为答案，以免使挑战帖子变得混乱）。
而且，尽管我想说这也是（尝试和）击败的事情，但这甚至不值得一提，因为，好吧。Java（几乎）总是被击败。; p

在线尝试。

输出示例：

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

在这里尝试输出的lambda函数。

输出示例：

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

说明：

main函数采用整数输入并返回String。它基本上返回一个quine函数，其中整数输入和开始时间（以秒为时间戳）作为硬编码值。

主功能：

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 在以下示例中使用：

第一个输出程序：

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

第二个输出程序：

与第一个输出程序相同，70492.687613232只是用代替70548。

Perl 5 + -p，88字节

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

输出程序必须与-M5.010for 一起运行say，但不能与-p。

在线尝试！

05AB1E，50 个字节

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

当然可以打更多的高尔夫球，但是输出一个半quine是很棘手的，该输出输出修改后的quine程序。

在线尝试或尝试运行20秒的示例。

说明：

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

示例结果程序：

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

它基于默认的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)

见我这个05AB1E尖端（部分如何使用字典？）理解为什么‘ÒÞ!是"BOOM!"。
注意：空格之间的原因çì是因为否则将其解释为字典字符串（triumph）’...’。