चुनौती:

एक प्रोग्राम या फ़ंक्शन बनाएं जो पूर्णांक इनपुट लेता है, जो नीचे दिए गए अनुसार एक नया प्रोग्राम / फ़ंक्शन आउटपुट करता है।

इनपुट:

पूर्णांक n: टाइम बम विस्फोट से पहले सेकंड में समय।

आउटपुट:

मूल कार्यक्रम जिसमें nइनपुट के रूप में सेकंड में समय था , एक नया कार्यक्रम / फ़ंक्शन आउटपुट करेगा जो निम्न करता है:

गया है nसेकंड पारित कर दिया क्योंकि पहले के कार्यक्रम चलाया गया था? छापBOOM!
Else: एक प्रोग्राम / फंक्शन प्रिंट करें, जो स्वयं चलाते समय टाइमर को nसेकंड्स में रीसेट करता है (और पहले आउटपुट प्रोग्राम / फंक्शन की तरह ही कार्य करता है)।

नोट: यह पहले आउटपुट प्रोग्राम / फ़ंक्शन (अधिकांश भाषाओं में कम से कम) के समान नहीं है, क्योंकि शुरुआती समय बदल गया है (नीचे स्पष्टीकरण उदाहरण देखें)।

छद्म कोड उदाहरण:

मान लीजिए कि मूल कार्यक्रम है ABCऔर इनपुट 60सेकंड है:

ABCऔर 60आउटपुट DEF(60)।

यदि DEF(60)60 सेकंड के भीतर चलाया जाता है, तो यह आउटपुट होगा DEF_G(60), जो बिल्कुल वैसा ही कार्य करता है DEF(60), लेकिन एक नए शुरुआती समय के साथ।
यदि DEF(60)60 सेकंड के बाद चलाया जाता है, तो यह आउटपुट करेगा BOOM!।

स्पष्टीकरण का उदाहरण है कि 'शुरुआती समय' के साथ मेरा क्या मतलब है:

इनपुट 60सेकंड के साथ बेस प्रोग्राम चलाया जाता है 12:00:00। यह शुरुआती समय के साथ पहला आउटपुट प्रोग्राम आउटपुट करता है 12:00:00।
के शुरुआती समय के साथ यह पहला आउटपुट प्रोग्राम 12:00:00चलाया जाता है 12:00:45। यह शुरुआती समय के साथ एक दूसरे आउटपुट प्रोग्राम को आउटपुट करता है 12:00:45।
के शुरुआती समय के साथ यह तीसरा आउटपुट प्रोग्राम 12:00:45है 12:01:25। यह चौथे आउटपुट प्रोग्राम को शुरू करने के समय के साथ आउटपुट करता है 12:01:25।
के शुरुआती समय के साथ यह चौथा आउटपुट प्रोग्राम 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, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा कॉल।
डिफ़ॉल्ट ढीले निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

code-golf quine date

— केविन क्रूज़सेन
स्रोत

"आउटपुट ए प्रोग्राम" का क्या अर्थ है? उत्पादन स्रोत कोड स्ट्रिंग के रूप में? या एक समारोह लौट रहे हैं?

— tsh

@tsh ने स्ट्रिंग और फंक्शन दोनों की अनुमति देने के लिए एक नियम जोड़ा।

— केविन क्रूज़सेन

2

जावास्क्रिप्ट, 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)}

ब्राउज़र में टेस्ट करें

— Maarten Bicknese
स्रोत

ऐसा लगता है कि यह अपेक्षा के अनुरूप काम नहीं कर रहा है।

— Maarten Bicknese

आप कर सकते हैं हटाने के पोस्ट, और अ-नष्ट यह एक बार तय हो गई, किसी भी नीचे वोट से बचने के लिए।

— tsh

आप अंतरिक्ष में गोल्फ कर सकते हैं return()=>। और यद्यपि मैं जावास्क्रिप्ट में लगभग कभी भी कार्यक्रम नहीं करता हूं, मैंने आपके परीक्षण-स्क्रिप्ट की जांच की और यहां तक कि इसे फ़ंक्शन आउटपुट के फ़ंक्शन के लिए एक परीक्षण जोड़कर संशोधित किया: इसे चौथे फ़ंक्शन-ऑफ-फ़ंक्शन परीक्षण के साथ यहां परीक्षण करें। सब कुछ काम करने लगता है, और यह आश्चर्यजनक रूप से छोटा है जो मैं जोड़ सकता हूं, इसलिए मुझ से +1। पुनश्च: नियमों में यह कहा गया है कि यह एक समारोह के बजाय एक स्ट्रिंग का उत्पादन करना चाहिए। लेकिन मैं दोनों को अनुमति देने के लिए नियमों को थोड़ा बदल दूंगा। क्या आप शायद स्क्रिप्ट को संशोधित कर सकते हैं इसलिए यह परीक्षण के दौरान लॉग करने के लिए फ़ंक्शन को भी आउटपुट करता है?

— केविन क्रूज़सेन

1

f=(t,o=setTimeout(_=>o=0,t*1e3))=>_=>o?f(t):'BOOM!'काम करना चाहिए

— tsh

क्या तुम एक जादूगर हो?! पैरामीटर डिफ़ॉल्ट मान के रूप में तर्क का उपयोग करने के बारे में कभी नहीं सोचा

— of

4

जावास्क्रिप्ट, 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
}());

स्निपेट का विस्तार करें

पुराना उत्तर (रिटर्न एक स्ट्रिंग होना चाहिए)

जावास्क्रिप्ट, 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
}());

स्निपेट का विस्तार करें

— TSH
स्रोत

अच्छा जवाब, और आश्चर्यजनक रूप से पठनीय। मैंने कुछ परीक्षण किया और सब कुछ ठीक काम करने लगता है। मुझ से +1।

— केविन क्रूज़सेन

1

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

मेरी अपनी चुनौती को अभी पोस्ट करने के लिए क्षमा करें। यह मुख्य रूप से चुनौती के आगे स्पष्टीकरण के रूप में अभिप्रेत है, और मुझे संदेह था कि क्या इसे स्वयं प्रश्न में जोड़ा जाए या इसे उत्तर के रूप में पोस्ट किया जाए (और इसे चुनौती पोस्ट को अव्यवस्थित नहीं करने के लिए उत्तर के रूप में पोस्ट करने का निर्णय लिया गया)।
और हालांकि मैं कहना चाहूंगा कि यह (कोशिश और) बीट के लिए भी कुछ है, क्योंकि यह भी ध्यान देने योग्य नहीं है क्योंकि, अच्छी तरह से .. जावा (लगभग) हमेशा पीटा जाता है। , पी

इसे ऑनलाइन आज़माएं।

उदाहरण आउटपुट:

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

स्पष्टीकरण:

मुख्य कार्य एक पूर्णांक इनपुट लेता है और एक स्ट्रिंग लौटाता है। यह मूल रूप से एक फ़ंक्शन देता है जो कि एक क्वीन है, पूर्णांक इनपुट और शुरुआती समय (सेकंड में टाइमस्टैम्प के रूप में) हार्ड-कोडिंग मान के रूप में।

मुख्य कार्य:

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।

— केविन क्रूज़सेन
स्रोत

1

पर्ल 5 + `-p`, 88 बाइट्स

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

आउटपुट कार्यक्रमों के साथ चलाने के किया जाना चाहिए -M5.010के लिए say, लेकिन नहीं -p।

इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स
स्रोत

0

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) के कारण के रूप में व्याख्या है ’...’।

— केविन क्रूज़सेन
स्रोत

टिकटिंग क्वीन-बम!

चुनौती:

इनपुट:

आउटपुट:

छद्म कोड उदाहरण:

स्पष्टीकरण का उदाहरण है कि 'शुरुआती समय' के साथ मेरा क्या मतलब है:

चुनौती नियम:

सामान्य नियम:

जावास्क्रिप्ट, 51 बाइट्स

पुराना संस्करण

जावास्क्रिप्ट, 53 बाइट्स

जावास्क्रिप्ट, 78 बाइट्स

जावा 8, 234 बाइट्स

स्पष्टीकरण:

पर्ल 5 + -p, 88 बाइट्स

05AB1E , 50 बाइट्स

पर्ल 5 + `-p`, 88 बाइट्स