ท้าทาย:

สร้างโปรแกรมหรือฟังก์ชั่นที่รับอินพุตจำนวนเต็มซึ่งส่งออกโปรแกรม / ฟังก์ชั่นใหม่ตามที่ระบุด้านล่าง

การป้อนข้อมูล:

จำนวนเต็มn: เวลาเป็นวินาทีก่อนที่ Time Bomb จะระเบิด

เอาท์พุท:

โปรแกรมต้นฉบับที่มีเวลาnเป็นวินาทีในการป้อนข้อมูลจะส่งออกโปรแกรม / ฟังก์ชั่นใหม่ที่ทำสิ่งต่อไปนี้:

• ได้nไม่กี่วินาทีที่ผ่านมาตั้งแต่โครงการก่อนหน้านี้ได้รับการทำงาน? พิมพ์BOOM!
• อื่น: พิมพ์โปรแกรม / ฟังก์ชั่นซึ่งเมื่อเรียกใช้ตัวเองจะรีเซ็ตตัวจับเวลากลับเป็นnวินาที (และทำหน้าที่เหมือนกับโปรแกรม / ฟังก์ชั่นเอาท์พุทแรก)

หมายเหตุ: มันไม่เหมือนกับโปรแกรม / ฟังก์ชั่นเอาท์พุทแรก (ในภาษาส่วนใหญ่อย่างน้อย) เนื่องจากเวลาเริ่มต้นมีการเปลี่ยนแปลง (ดูตัวอย่างคำอธิบายด้านล่าง)

ตัวอย่างรหัสเทียม:

สมมติว่าโปรแกรมต้นฉบับคือABCและอินพุตเป็น60วินาที:

ABCและเอาท์พุท60DEF(60)

• หากDEF(60)ทำงานภายใน 60 วินาทีมันจะแสดงผลDEF_G(60)ซึ่งจะทำหน้าที่เหมือนกับDEF(60)แต่ด้วยเวลาเริ่มต้นใหม่
• หากDEF(60)ทำงานหลังจาก 60 วินาทีมันจะออกBOOM!มา

ตัวอย่างการชี้แจงสิ่งที่ฉันหมายถึงด้วย 'เวลาเริ่มต้น':

1. โปรแกรมฐานด้วยการป้อนข้อมูลวินาทีจะดำเนินการที่60 มันออกโปรแกรมการส่งออกเป็นครั้งแรกที่มีเวลาเริ่มต้นของ12:00:0012:00:00
2. โปรแกรมนี้เอาท์พุทเป็นครั้งแรกกับการเริ่มต้นช่วงเวลาของการจะดำเนินการที่12:00:00 มันออกโปรแกรมเอาท์พุทที่สองด้วยเวลาเริ่มต้นของ12:00:4512:00:45
3. โปรแกรมนี้เอาท์พุทที่สามกับเวลาเริ่มต้นของการเรียกใช้ที่12:00:45 มันออกโปรแกรมการส่งออกที่สี่ที่มีเวลาเริ่มต้นของ12:01:2512:01:25
4. โปรแกรมนี้เอาท์พุทที่สี่ที่มีเวลาเริ่มต้นของการเรียกใช้ที่12:01:25 มันจะออก12:05:00BOOM!

หมายเหตุวิธีการส่งออกก่อนจะพิมพ์BOOM!หลัง12:01:00แต่โปรแกรมการส่งออกมีความก้าวหน้าดังนั้นแม้ว่าจะเป็น12:01:25ในขั้นตอนที่ 3 ก็จะยังคงส่งออกโปรแกรมต่อไปแทนBOOM!(เพราะโปรแกรมเอาท์พุทของการส่งออกได้เริ่มต้นครั้งเกินโปรแกรมผลลัพธ์ที่แรก) .

กฏท้าทาย:

• ใช้กฎ quine เริ่มต้น
• อย่างน้อยnวินาทีควรผ่าน ดังนั้นถ้าใส่เป็น60และเริ่มต้นเวลา12:00:00ที่12:01:00มันจะยังคงส่งออกโปรแกรม v2 แต่ที่มันจะออก12:01:01BOOM!
• โปรแกรมเอาต์พุตจะไม่รับอินพุตใด ๆ ( ยกเว้นพารามิเตอร์ว่างที่ไม่ได้ใช้หากมีขนาดสั้นกว่า ) ควรกำหนดเวลาเริ่มต้นให้กับโปรแกรมถัดไปเป็นค่า 'ฮาร์ดโค้ด' (ซึ่งเป็นสาเหตุที่เอาต์พุตของโปรแกรมเอาต์พุตไม่เหมือนกันกับโปรแกรมก่อนหน้า (ในภาษาส่วนใหญ่)
• เฉพาะขนาดของโปรแกรม / ฟังก์ชั่นหลักของคุณเท่านั้นที่ถูกนับเป็นไบต์
• คุณสามารถส่งออกโปรแกรม / ฟังก์ชั่นไม่ว่าจะเป็นสตริง (หรือรูปแบบที่เหมาะสมเทียบเท่าเช่นไบต์ / อักขระอาร์เรย์ / รายการ) เป็นฟังก์ชั่นหากภาษาของคุณรองรับสิ่งนี้หรือรูปแบบอื่น ๆ ที่สมเหตุสมผล (โปรดถามว่าคุณไม่แน่ใจ)

กฎทั่วไป:

• นี่คือ รหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์จะเป็นผู้ชนะ
  อย่าปล่อยให้ภาษาโค้ดกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ได้เข้ารหัส พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานใช้สำหรับคำตอบของคุณดังนั้นคุณจึงได้รับอนุญาตให้ใช้ 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);}

ลองฟังก์ชั่นแลมบ์ดาเอาท์พุทที่นี่

ตัวอย่างผลลัพธ์:

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

คำอธิบาย:

ฟังก์ชั่นหลักใช้เวลาใส่จำนวนเต็มและส่งกลับสตริง โดยทั่วไปแล้วมันจะส่งคืนฟังก์ชันซึ่งเป็น quine โดยมีอินพุตจำนวนเต็มและเวลาเริ่มต้น (ในหน่วยวินาทีเป็น timestamp) เป็นค่าตายตัว

ฟังก์ชั่นหลัก:

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.68761323270548

Perl 5 + -p, 88 ไบต์

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

โปรแกรมการส่งออกจะต้องทำงานด้วย-M5.010สำหรับแต่ไม่say-p

ลองออนไลน์!

05AB1E , 50 ไบต์

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

สามารถเล่นกอล์ฟได้มากกว่าเดิมเล็กน้อย แต่มันค่อนข้างยากที่จะแสดงผลกึ่งควินซึ่งแสดงผลโปรแกรมควินที่มีค่าดัดแปลง

ลองมันออนไลน์หรือพยายามเป็นตัวอย่างที่วิ่ง 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®:ë‘ÒÞ!

"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’...’