ऑटोमेटिक सेविंग द वर्ल्ड

63

आप डेसमंड ह्यूम हैं। पिछले 3 वर्षों से, आप और आपके साथी केल्विन एक ऐसे कंप्यूटर के गुलाम रहे हैं, जिसे दुनिया को बचाने के लिए हर 108 मिनट में एक बहुत ही विशिष्ट अनुक्रम की आवश्यकता होती है।

4 8 15 16 23 42

आपका साथी 40 दिन पहले मर गया था (केल्विन के सिर और एक बड़ी चट्टान से जुड़े एक दुर्भाग्यपूर्ण दुर्घटना के कारण), और आपके पास बात करने के लिए कोई नहीं है। आपके लिए नंबर डालने वाला कोई नहीं। एकरसता को तोड़ने वाला कोई नहीं। पहले तो यह बहुत बुरा नहीं था, लेकिन आप अब चुप नहीं रह सकते। और अगर आपको एक बार "मेक योर ओन काइंड ऑफ म्यूजिक" सुनना है, तो आप चिल्लाने वाले हैं।

आप तय करते हैं कि आपको बाहर निकलने की जरूरत है। नौ - दो ग्यारह होना। आप तय करते हैं कि आप द्वीप से एक बेड़ा और पाल का निर्माण करेंगे। लेकिन तब आपको बुरी खबर का एहसास होता है: आप यहां फंस गए हैं। आपको दुनिया को बचाए रखने की जरूरत है।

लेकिन तब आपको अच्छी खबर का एहसास होता है: आप एक प्रोग्रामर हैं! आप दुनिया को बचाने के लिए स्वचालित कर सकते हैं! उत्साहित, आप कंप्यूटर पर भागते हैं, और, अपने भरोसेमंद अजगर कौशल का उपयोग करके, आप अपने लिए संख्याओं को दर्ज करने के लिए एक त्वरित स्क्रिप्ट को कोड़ा मारते हैं।

import time

while True:
    print "4 8 15 16 23 42"
    time.sleep(60 * 107)

त्वरित, सरल, विश्वसनीय, लघु और आसान। सब कुछ है कि एक अच्छा अजगर स्क्रिप्ट होना चाहिए। लेकिन फिर, जब आप इसका परीक्षण करने की कोशिश करते हैं, तो आपको एक त्रुटि मिलती है।

Bad command or file name.

हुह, अजीब। ओह ठीक है, चलो सी + + की कोशिश करते हैं।

#include <iostream>
#include <unistd.h> 

int main()
{
    while (true)
    {
        std::cout << "4 8 15 16 23 42" << std::endl;
        sleep(60 * 107);
    }
}

नहीं! C ++ नहीं मिला है। आप हर उस भाषा को आजमाते हैं जिसके बारे में आप सोच सकते हैं। जावास्क्रिप्ट, रूबी, पर्ल, पीएचपी, सी #। कुछ भी तो नहीं। यह कंप्यूटर दिन के सभी लोकप्रिय भाषाओं से पहले बनाया गया था।

चुनौती

आपको एक प्रोग्राम लिखना होगा जो होगा:

1) इसे ठीक से प्रिंट करें: "4 8 15 16 23 42" (बिना उद्धरण के)

2) 104 और 108 मिनट के बीच कुछ समय प्रतीक्षा करें। ( द लॉस्ट विकी के अनुसार )

3) हमेशा के लिए दोहराएं। (या जब तक आप यह महसूस नहीं करते कि यह सब एक विस्तृत घोटाला है, और आप आलसी लेखन के कारण एक अजीब अंग में फंस गए हैं, और ऐसे प्रश्न पूछ रहे हैं जिनके लिए आपके पास कोई जवाब नहीं है। धन्यवाद जे जे अब्राम!)

हालांकि एक पकड़ है: आप एक ऐसी भाषा का उपयोग करते हैं जो हंस स्टेशन में कंप्यूटर वास्तव में चलने में सक्षम होगा। ऐसा मानते हुए

ए) निर्माण के समय कंप्यूटर अप टू डेट था,

बी) कंप्यूटर सॉफ्टवेयर के लिए कोई अद्यतन नहीं किया गया है, और

सी) कोई इंटरनेट कनेक्शन उपलब्ध नहीं है (मतलब कि आप गोल्फस्क्रिप्ट डाउनलोड नहीं कर सकते ...),

और द स्वान स्टेशन, (अगेन, द लॉस्ट विकी ) की निर्माण तिथि के लिए अपना सर्वश्रेष्ठ अनुमान लगा रहे हैं ।

इसका मतलब है कि आपको ऐसी भाषा का उपयोग करना होगा जो 31 दिसंबर, 1977 को या उससे पहले जारी की गई थी।


कुछ नियम स्पष्टीकरण:

  • पुस्तकालयों को शामिल करना ठीक है, लेकिन एक ही नियम लागू होता है (पुस्तकालयों को 1977 से पहले का होना चाहिए)।

  • आपको ओएस संगतता के बारे में चिंता करने की ज़रूरत नहीं है।

  • यदि आप उपयोग करते हैं system, या आपकी भाषाएं समान हैं, तो आपको यह साबित करना होगा कि आपके द्वारा उपयोग किया जाने वाला कोई भी सिस्टम 1978 से पहले उपलब्ध होगा। एक विकिपीडिया लेख शायद इसे साबित करने का सबसे अच्छा तरीका है।

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

यह कोड-गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

code-golf  kolmogorov-complexity  date 
— DJMcMayhem
स्रोत
क्या प्रत्येक आउटपुट के अंत में एक नई पंक्ति आवश्यक है?
— मेगो
3
@Mego हाँ, अन्यथा संख्या वास्तव में दर्ज नहीं होगी ।
— डीजेमेक्मे

जवाबों:

11

एपीएल , 28 24 25 24 बाइट्स

इसने STSC के APL * PLUS में और IPSA के SharpAPL में 1977 में काम किया, और जबकि आधुनिक APL में नई विशेषताओं का एक टन है, यह आज भी सभी प्रमुख APL पर काम करता है:

+\4 4 7 1 7 19
→×⎕DL 6360

पहली पंक्ति दिखाए गए संख्याओं के संचयी योग को प्रिंट करती है, जो आवश्यक संख्याएं हैं। दूसरी पंक्ति d e l ays 6360 सेकंड (106 मिनट), उसके बाद उस (1, जाहिर है) के हस्ताक्षर को लेती है, और उस रेखा (यानी पिछले, संख्या-मुद्रण एक) पर जाती है।

हालांकि, 1966 से एपीएल \ 360 ( आईबीएम सिस्टम / 360 के लिए एपीएल ) वास्तव में इसे एक बाइट ( फ्री आईबीएम / 370 एमुलेटर पर परीक्षण) द्वारा धड़कता है :

+\4 4 7 1 7 19
5⌶19E5
→1

नींद मैं बीम ( " आईबीएम ?" - इसे पाने के) में इंतजार-समय लगता है jiffies का 1 / 300 वें एक दूसरे की, तो हम 19 × 10 इंतजार 5 jiffies = 105 मिनट और 33 1 / 3 सेकंड।

— एडम
स्रोत
मैं अपना सारा समय अब ​​से किलोजिफीज और मेगाजीफिज में माप रहा हूं।
— पावेल
+\⎕A⍳'EEHBHT'(अगर ⎕IO=0)
— ngn 20’18
@ng APL * प्लस के पास नहीं है ⎕A।
— एडम जूल 20'18
@ +\4 4 7 1 7 19तब तक?
— ngn
@ Adám ping ^
— ngn
26

MUMPS - 30 वर्ण, लगभग 1966 (1977 में ANSI मानक)

कोड गोल्फ में मेरा पहला प्रयास, यहाँ हम चलते हैं!

f  w "4 8 15 16 23 42" h 6420

MUMPS अभी भी EHR सॉफ्टवेयर के लिए एक लोकप्रिय भाषा है, जो बोस्टन में मैसाचुसेट्स जनरल अस्पताल द्वारा बनाई गई है। अधिकांश ज्ञात कार्यान्वयन वेरोना, WI में एपिक सिस्टम है।

— एंड्रयू रॉबिन्सन
स्रोत
6
अच्छा काम! MUMPS वास्तव में कोड गोल्फिंग के लिए आदर्श है कि क्या आप नर्क के उस विशेष दायरे में प्रवेश करना चाहते हैं ...
2
अगर दुनिया दांव पर थी तो मैं शुरू में "U 0" रख सकता था ...
— psr
5
@psr, क्या अधिक महत्वपूर्ण है: दुनिया को बचाने या कोड गोल्फिंग ?!
— एंड्रयू रॉबिन्सन
2
@psr क्या आप किसी ऐसे व्यक्ति को मजाक समझा सकते हैं जिसने इससे पहले MUMPS के बारे में कभी नहीं सुना है? मैं नहीं, सिर्फ उह-- काल्पनिक रूप से। मामले में जो किसी ने MUMPS के बारे में नहीं सुना है वह इस पर ठोकर खाता है। ;)
— डीजेएमकेम
3
@DJMcMayhem - लेखन विवरण ("डब्ल्यू") वर्तमान आउटपुट डिवाइस को लिखता है (कौन सा उपकरण वर्तमान है वैश्विक मान लिया जाता है कि आप उस विचार को पसंद करते हैं या नहीं)। वर्तमान डिवाइस शायद मानक आउटपुट होने जा रहा है। लेकिन U 0 इसे मानक आउटपुट पर सेट करेगा (एर, आमतौर पर, लेकिन इसमें जाना अब किसी के लिए मज़ेदार नहीं होगा)।
— Psr
20

टीईसीओ, 53 बाइट्स

TECO (पाठ [पहले टेप] संपादक और सुधारक) 1962 में उत्पन्न होने वाला एक पाठ संपादक है। इसका उपयोग स्टैंडअलोन प्रोग्राम चलाने के लिए भी किया जा सकता है। यह पीडीपी, वैक्सन आदि के लिए अत्याधुनिक संपादक है।

टीईसीओ मैनुअल के अनुसार, ^Hकमांड दिन का समय देता है। अपने ऑपरेटिंग सिस्टम और बिजली की आपूर्ति की जाँच करना सुनिश्चित करें, क्योंकि समय की इकाई आपकी मशीन के अनुसार भिन्न हो सकती है:

OS/8:      ^H = 0
RT-11:     ^H = (seconds since midnight)/2
RSTS/E:    ^H = minutes until midnight
RSX-11:    ^H = (seconds since midnight)/2
VAX/VMS:   ^H = (seconds since midnight)/2
TOPS-10:   ^H = 60ths of a second since midnight
(or 50ths of a second where 50 Hz power is used)

निम्नलिखित कार्यक्रम उन प्रणालियों पर काम करता है जहां दिन का समय सेकंड / 2 में मापा जाता है:

I4 8 15 16 23 42
$<HT^HUA<^H-QAUDQD"L43200%D'QD-3180;>>

ध्यान दें कि ^Hऔर $क्रमशः, नियंत्रण-एच और ESCAPE द्वारा हड़ताली में प्रवेश किया जाना चाहिए।

कार्यक्रम में संख्याओं को निम्नलिखित मशीनों के लिए समायोजित किया जा सकता है:

   (number)        43200     3180
RSTS/E              1440      106
TOPS-10 60 Hz    5184000   381600
TOPS-10 50 Hz    4320000   318000
OS/8             goodbye, world...
— feersum
स्रोत
20

बॉर्न शेल, 47 45 बाइट्स

while echo 4 8 15 16 23 42;do sleep 6420;done
— Doorknob
स्रोत
2
मुझे इससे हराएं। मैं सबूत खोजने की कोशिश कर रहा था जो कि sleepवास्तव में उपलब्ध था - तब क्या आपने पाया? en.wikipedia.org/wiki/…
— डिजिटल ट्रामा
आप शर्त के sleepरूप में उपयोग कर सकते whileहैं। 2 बाइट्स बचाता है
— थिंकचोस
@plg वह नंबर अनुक्रम आउटपुट करने से पहले सो जाएगा , जिसे अनुमति नहीं दी जाती है (इसे प्रोग्राम चलाने के तुरंत बाद अनुक्रम को प्रिंट करना होगा, फिर सो जाएं)।
— दरवाज़े
5
इसलिए आप अंतिम बार मैन्युअल रूप से संख्याओं को इनपुट करने के तुरंत बाद कार्यक्रम शुरू करते हैं। ;)
— रोजर
1
यूनिक्स संस्करण 6 में स्लीप कमांड शामिल था (देखें man.cat-v.org/unix-6th/1/sleep )।
— मत्तेओ इटालिया
13

फोरट्रान 66 ( 108 98 बाइट्स)

      PROGRAM D 
2     WRITE (*,*) '4 8 15 16 23 42'
      CALL SLEEP(6420)
      GOTO 2
      END

यह निश्चित है कि प्रश्न में कंप्यूटर के पास फोरट्रान संकलक था, क्योंकि यह युग में वैज्ञानिक और इंजीनियरिंग क्षेत्रों पर हावी था। मैं जन्म के वर्ष के 18 साल बाद पैदा हुआ था, लेकिन विश्वविद्यालय में अपने गणित कार्यक्रम के दौरान हमने फोरट्रान सीखा। एक मजेदार व्याख्यान हमने सीखा कि कैसे पंचिंग कार्ड पर प्रोग्राम करना है। यहां इसे सही तरीके से प्रारूपित करना इतना आसान नहीं है, प्रत्येक आदेश से पहले 6 कंबल होने चाहिए और मुझे केवल फोरट्रान 77 के लिए स्लीप-फंक्शन का संदर्भ मिल सकता है लेकिन यह फोरट्रान IV और 66 में पहले से मौजूद होना चाहिए।

पुनश्च: हम लेबल 42 के बजाय लेबल 1 का उपयोग करके एक बाइट को स्क्रैप कर सकते हैं।

PPS: यदि प्रश्न में कंप्यूटर प्रोग्राम इनपुट के लिए पंचिंग-कार्ड का उपयोग करता है, तो आप भाग्य से बाहर हैं और बाइट्स अब कोई मायने नहीं रखते: डी।

— Bersaelor
स्रोत
@proudhaskeller नहीं, बाएं 7 कॉलम आरक्षित हैं, इसलिए आप केवल पंक्ति 4 के अंत में एक बाइट
— बचाते हैं
1
वास्तव में, मैं केवल एक ही बाइट को सुरक्षित करूँगा कि मैंने इसे क्यों नहीं बदला?)
— बर्सेलर
3
आह, अनिवार्य व्हाट्सएप मेरी आंख में एक उदासीन आंसू डालता है: D
— Yves Klett
तुम भी एक बाइट के 60*107साथ जगह से दाढ़ी सकता 80**2है।
— मार्क
ठीक है, लेकिन फिर एक भी 6420 का उपयोग कर सकते हैं।
— Bersaelor
11

मैकलिस्प, 47 46 बाइट्स

(do()(())(print"4 8 15 16 23 42")(sleep 6360))

1974 के संदर्भ मैनुअल (पीडीएफ) से लिए गए सभी निर्माण । हालांकि इसका परीक्षण नहीं किया गया है क्योंकि मेरे पास मैकप्लिस दुभाषिया नहीं है।

— उड़ी ग्रामटा
स्रोत
1
एक बाइट बचाओ, nilलिखा जा सकता है()
— coredump
10

अल्टेयर बेसिक

निश्चित रूप से, डेसमंड और केल्विन ने केवल मनोरंजन के लिए एक Altair 8800 (या एक एमुलेटर) रखा होगा। अल्टेयर बेसिक (बिल गेट्स नाम के एक लड़के से, कुछ छोटे दो-आदमी स्टार्ट-अप जिसे माइक्रो-सॉफ्ट कहा जाता है) एक 1975 की रिलीज के साथ स्क्वॉइस।

डेसमंड को FORएक मिनट ठीक करने की जरूरत होती है ताकि यह सुनिश्चित हो सके कि आंतरिक लूप एक मिनट रहता है। वापस तो, हर कोई जानता था कि व्यस्त लूप गलत थे, लेकिन हर कोई उनका इस्तेमाल करता था!

1 REM ADJUST "D" AS REQUIRED
2 LET D = 1000
3 PRINT "4 8 15 16 23 42"
4 FOR A = 0 TO 105 * 60
5 REM THIS LOOP SHOULD LAST ONE MINUTE +/- 0.05 SECONDS
6 FOR B = 0 TO D
7 LET C = ATN(0.25)
8 NEXT
9 NEXT
10 GOTO 3

एक विकल्प के रूप में, डेसमंड 88-आरटीसी बोर्ड (घटकों से इकट्ठे !: http://www.classiccmp.org/altair32/pdf/88-virtc.pdf ) स्थापित कर सकता है और एक वास्तविक समय घड़ी बंद करने के लिए इंटरप्ट के माध्यम से पहुंच प्राप्त कर सकता है। पावर लाइन या आंतरिक क्रिस्टल।

उसे घड़ी के इनपुट को संभालने के लिए एक इंटरप्ट रुटीन लिखना होगा, जो बदले में एक पोर्ट को अपडेट कर सके, हर 59 सेकंड में एक सेकंड के लिए जमीन पर लाने के लिए कहे।

अल्टेयर बेसिक का एक WAITफंक्शन था, इसलिए कोड को कुछ इस तरह से सरल बनाया जाएगा (मुझे पोर्ट लिस्टिंग नहीं मिल रही थी, इसलिए मैंने सिर्फ 125 को चुना, उम्मीद है कि यह अप्रयुक्त होगा।):

1 PRINT "4 8 15 16 23 42"
2 FOR A = 0 TO 105 * 60
3 WAIT 125,0
4 WAIT 125,255
5 NEXT
6 GOTO 1

यह वास्तव में एक मजेदार सा सवाल था, कुछ वास्तव में अल्पविकसित कंप्यूटरों में वापस जाना। धैर्य उन पुराने टाइमर (मेरे सहित) का होना चाहिए था!

2
आह, व्यस्त छोरों ... +1
— भूत
4
हम्म, डेसमंड, अल्टेयर ... क्या किसी भी संयोग से "एजियो" नामक भाषा है?
— Kroltan
10

यूनिक्स सिस्टम 6 के लिए पीडीपी -11 कोडांतरक - 73 68 74 वर्ण

70 के दशक के बारे में बात करते हुए, यूनिक्स और हार्डवेयर को सम्मानित करना अनिवार्य है जहां यह सब शुरू हुआ!

s:mov $1,r0
sys write;m;18
mov $6240.,r0
sys 43
br s
m:<4 8 15 16 23 42;>

आप इसे आसानी से यहां चला सकते हैं (लेकिन पहले आपको edपाठ सम्मिलित करने के लिए उपयोग किए जाने वाले खुशियों को फिर से खोजना होगा - मेरे विशिष्ट मामले में, मुझे यह भी पता लगाना था कि वास्तव में पाठ को कैसे संपादित किया जाए :))।

माना जाता है कि यह 108 बाइट्स बन जाता है।

# cat mini.as
s:mov $1,r0
sys write;m;18
mov $6240.,r0
sys 43
br s
m:<4 8 15 16 23 42;>
# as mini.as
# ls -l a.out mini.as
-rwxrwxrwx  1 root      108 Oct 10 12:36 a.out
-rw-rw-rw-  1 root       74 Oct 10 12:36 mini.as
# od -h a.out
0000000 0107 0022 0000 0000 0018 0000 0000 0000
0000020 15c0 0001 8904 0012 0010 15c0 0004 8923
0000040 01f7 2034 2038 3531 3120 2036 3332 3420
0000060 3b32 0000 0000 0000 0002 0000 0000 0000
0000100 0000
0000120 0000 0000 0073 0000 0000 0000 0002 0000
0000140 006d 0000 0000 0000 0002 0012
0000154 
# ./a.out
4 8 15 16 23 42;
— माटेओ इटालिया
स्रोत
1
2 कम वर्णों के लिए \ n निकालें, उन्होंने यह नहीं कहा कि इसे अलग-अलग लाइनों में होना चाहिए। :)
— एंड्रयू रॉबिन्सन
@AndrewRobinson: यह थोड़ा अनुचित लगता है, इसके बाद आने वाले सभी आउटपुट में 4 को 42 के साथ एक साथ जोड़ा जाएगा ... मैं इसके बजाय अर्धविराम के साथ \ n (दो अक्षर) बदल सकता था। इसके अलावा, msgबेकार है, मैं m(अन्य 4 बाइट्स शेविंग) के साथ जा सकता हूं ।
— मत्तेयो इटालिया
1
आप के brबजाय का उपयोग करके एक पत्र और एक निर्देश शब्द बचा jmpहोगा, नहीं? इसके अलावा, लिखने के लिए r0 में फाइल डिस्क्रिप्टर की आवश्यकता होती है - आप जाहिरा तौर पर अपने पहले लूप के लिए इसमें 1 (या 2) होते हैं, लेकिन आप इसे अपने सोने के समय के साथ स्मैश कर रहे हैं।
— रैंडम 832
@ Random832: wops, यह संभवत: तब काम किया जब मैंने इसका परीक्षण किया क्योंकि मैंने 1 या 2 का उपयोग सोने के समय के रूप में किया था ताकि अगर यह काम करे के बारे में सही br, उस एक और कुछ अन्य चाल (मुख्य रूप से व्हाट्सएप पर काटने और जब भी संभव हो ऑक्टल का उपयोग करने के लिए) के लिए धन्यवाद, हमें 74 वर्णों को मिला पहले भी जोड़ दिया mov।
— माटेओ इटालिया
8

लोगो, 61 बाइट्स (संभवतः) या 48 बाइट्स (शायद नहीं)

दुर्भाग्य से, मैं बीबीएन द्वारा लोगो सिस्टम: प्रारंभिक मैनुअल (1967), या एमआईटी लोगो समूह (1960 के दशक) द्वारा किसी भी संदर्भ की एक ऑनलाइन प्रति खोजने में कामयाब नहीं रहा हूं । LCSI द्वारा Apple लोगो हाल ही में (~ 1980) थोड़ा सा है। हालाँकि, ऑनलाइन पुस्तकों के आधार पर, निम्नलिखित में से कुछ भिन्नताएँ शायद उस समय काम की थीं। ध्यान दें कि WAIT 60 1 सेकंड के लिए इंतजार कर रहा है, न कि 60।

TO a
LABEL "l
PRINT [4 8 15 16 23 42]
WAIT 381600
GO "l
END
a

हम पूंछ कॉल अनुकूलन के साथ थोड़ा बेहतर कर सकते हैं, हालांकि यह उस समय उपलब्ध नहीं था।

TO a
PRINT [4 8 15 16 23 42]
WAIT 381600
a
END
a
— उड़ी ग्रामटा
स्रोत
3
उस समय TCO बिल्कुल उपलब्ध था। (हां, मुझे अनुभव से पता है।) TCO लिस्प (और फिर योजना) के लिए आदर्श था; यह केवल हाल ही में है कि यह विदेशी रूप में देखा जाने लगा है।
— रिसी
7

सीबीएम बेसिक 1.0, 52 38 अक्षर, 45 31 बाइट्स के लिए टोकन

1?"4 8 15 16 23 42":fOa=1to185^3:nE:rU

CBM BASIC 1.0 को अक्टूबर 1977 में Commodore PET के साथ पेश किया गया था। कमांड्स को आमतौर पर अपरकेस और CBM ग्राफ़िक्स वर्णों में दिखाया जाएगा, लेकिन मैंने उन्हें यहाँ आसानी से (मेरा और आपका दोनों)! )। ध्यान दें कि ^ वास्तव में would के रूप में प्रदर्शित किया जाएगा। इस के साथ सूचीबद्ध करने के बाद, इसका पता लगाया LISTगया:

1 PRINT "4 8 15 16 23 42":FOR A=1 TO 185^3:NEXT:RUN

PET का 6502 रन 1MHz पर था, इसलिए इसे पूरा होने में लगभग 105 मिनट का समय लगना चाहिए।

संपादित करें : एहसास हुआ कि नेस्टेड लूप वास्तव में आवश्यक नहीं थे और मैं अपने टोकन को गलत तरीके से लिखूंगा। अभी भी जीतने के लिए पर्याप्त नहीं है (और बहुत देर हो चुकी है, बूट करने के लिए), लेकिन कम से कम यह बेहतर है।

— निशान
स्रोत
7

पास्कल - 107 95 बाइट्स

PROGRAM S;USES CRT;BEGIN WHILE TRUE DO BEGIN WRITELN('4 8 15 16 23 42');DELAY(6300000);END;END.

Ungolfed संस्करण:

PROGRAM S;
USES CRT;
BEGIN
    WHILE TRUE DO
    BEGIN
        WRITELN('4 8 15 16 23 42');
        DELAY(6300000); { 105 minutes * 60 seconds * 1000 milisseconds }
    END;
END.
— रोडोल्फो डायस
स्रोत
4

फोर्थ , 50 बाइट्स

यद्यपि FORTH-79 सबसे शुरुआती मानकीकृत संस्करण है, लेकिन भाषा 1968 में शुरू होने वाले विकास में थी, और आईबीएम 1130 पर प्रयोग करने योग्य थी। 1977 के आसपास आने से पहले इसका उपयोग अन्य प्रणालियों पर भी किया गया था। मैं ये सुनिश्चित करने के लिए थोड़ा और शोध कर सकता हूं कि ये शब्द सभी उपलब्ध थे, लेकिन मुझे पूरा यकीन है कि यह तब तक बुनियादी है जब तक इसका अस्तित्व है। ये सभी FORTH-79 द्वारा, निश्चित रूप से उपलब्ध थे।

हमेशा के लिए लूप्स, स्ट्रिंग प्रिंटिंग के बीच 6420000 मिलीसेकंड का इंतजार। कोई नई रेखा नहीं छपी है।

: F 0 1 DO 6420000 MS ." 4 8 15 16 23 42" LOOP ; F
— mbomb007
स्रोत
4

स्मालटाक, 95 (या 68 अगर खामी की अनुमति है)

1972 के आसपास रहा

|i|[i:=0.[i<5] whileTrue: [(Delay forSeconds: 6480) wait.Transcript show: '4 8 15 16 23 42'.]]fork

इसका कोई अनुभव नहीं है, इसे विकिपीडिया पर
देखा : पी ने इसे ऑनलाइन देखा कि कैसे लूप और देरी की जाती है, वाक्यविन्यास सही होना चाहिए लेकिन इसे चलाने का कोई तरीका नहीं मिल सकता है।

संभव बचाव का रास्ता

इसे हर 108 मिनट में अनुक्रम को प्रिंट करना चाहिए, लेकिन यह नहीं बताता है कि इसे 108 मिनट होना चाहिए।
यह कोड को कम कर सकता है 

|i|[i:=0.[i<5] whileTrue: [Transcript show: '4 8 15 16 23 42'.]]fork

कोड बिना किसी अंतराल के अनुक्रम को प्रिंट करेगा, इसलिए इसकी गारंटी है कि यह 108 मिनट के बाद भी प्रिंट होगा।

— तेन प्रून
स्रोत
9
लेकिन समस्या यह कहती है Wait some time between 104 and 108 minutes, इसलिए मुझे नहीं लगता कि खामी संभव है।
— मैटजॉयस
@ मैट्सजॉयस जिसके कारण मैंने एक टाइमर के साथ एक पोस्ट किया और एक बिना :)
— Teun Pronk
3
जबकि आपका बचाव चुनौती के लिए काम नहीं करता है, मुझे आश्चर्य है कि अगर डेसमंड इसके साथ दूर जाने में सक्षम होगा। मुझे पूरा यकीन है कि जब तक यह 104-108 मिनट की खिड़की के बीच नहीं होता, तब तक कंप्यूटर कुछ भी नहीं करता है, इसलिए यह सिर्फ "4 8 15 16 23 42" को नजरअंदाज कर देगा। हालांकि, मुझे यकीन है कि वॉल्ट उन सभी नंबरों से बहुत भ्रमित होगा, जो कोई उसे भेज रहा है। = डी
— डीजेएमकेम
3

एसएएस, 82 75 69

data;
file stdout;
a:;
put "4 8 15 16 23 42";
a=sleep(6300,1);
goto a;
run;

एक सामान्य गोल्फिंग भाषा नहीं है, लेकिन मुझे लगता है कि यह इस चुनौती के लिए योग्य है, यह मानते हुए कि यह file stdout1977 के युग के एसएएस में मान्य था।

सुधार:

  • data _null_;-> data;7 वर्णों को बचाता है (और अब एक खाली डेटासेट के साथ-साथ stdout में छपाई करता है)।
  • गोटो के साथ लूप-टू-लूप बदला - 6 वर्ण बचाता है
— user3490
स्रोत
3

थॉम्पसन शेल, 1971 (स्लीप कमांड के लिए 1973)

43 बाइट्स

: x
echo 4 8 15 16 23 42
sleep 6480
goto x

बॉर्न शेल के बाद से, हालांकि यह 1977 में अस्तित्व में था, 1979 में v7 तक यूनिक्स के जारी संस्करण में नहीं था। मूल यूनिक्स शेल में कोई फैंसी लूप नियंत्रण आदेश नहीं था। (यदि आप एक लूप को समाप्त करना चाहते हैं, तो आप ifकमांड का उपयोग गोटो को छोड़ने के लिए कर सकते हैं ।)

— Random832
स्रोत
क्या यह exec $0एक छोटी बचत के लिए था goto?
— नील
2

सी, 50 बाइट्स

अन्य सी समाधान की तुलना में कम है, और इस प्रकार एक डुप्लिकेट नहीं है। डिजिटल ट्रॉमा के (लगभग) समान सी अन्य समाधान पर टिप्पणी करने से पहले मैंने वास्तव में यह लिखा था।

main(){for(;;sleep(6240))puts("4 8 15 16 23 42");}
— बिल्ली
स्रोत
मेरा तर्क है कि यह अन्य समाधान पर एक तुच्छ संशोधन / सुधार है, और इस प्रकार एक द्वैध है। यह लिखने से पहले आपने टिप्पणी देखी या नहीं, यह अप्रासंगिक है।
— मेगो
1

COBOL, 240 बाइट्स

हां, प्रमुख व्हाट्सएप महत्वपूर्ण है। संकलन करें और पसंद करें cobc -x save.cob; ./save। ( -xविकल्प एक साझा देयता के विपरीत एक निष्पादन योग्य बनाता है और इस प्रकार मुझे नहीं लगता कि इसे गिनने की आवश्यकता है।)

       IDENTIFICATION DIVISION.
       PROGRAM-ID.S.
       PROCEDURE DIVISION.
           PERFORM UNTIL 1<>1
              DISPLAY"4 8 15 16 23 42"
              CALL"C$SLEEP"USING BY CONTENT 6402
           END-PERFORM.
           GOBACK.

यदि हम उबाऊ होना चाहते हैं, तो हम --freeफ्री-फॉर्मेट कोड के लिए संकलन विकल्प जोड़ सकते हैं , फिर 158 + 6 = 164 बाइट्स लेकिन यह '77 में वापस काम करने की संभावना नहीं होगी।

IDENTIFICATION DIVISION.
PROGRAM-ID.S.
PROCEDURE DIVISION.
PERFORM UNTIL 1<>1
DISPLAY"4 8 15 16 23 42"
CALL"C$SLEEP"USING BY CONTENT 6402
END-PERFORM.
GOBACK.
— बिल्ली
स्रोत
1

ALGOL 60/68 / W, 74 47 50 बाइट्स

a68g save.a68का उपयोग करके, इस पूरे कार्यक्रम को चलाएं algol68g।

ALGOL में सोने का बिलकुल रास्ता नहीं है लेकिन हम अनिवार्य रूप से दौड़ सकते हैं /bin/sleep:

DO print("4 8 15 16 23 42");system("sleep 6380")OD

पुराना उत्तर:

ALGOL में एक नींद का निर्माण नहीं होता है, इसलिए हम 74 69 बाइट्स के लिए pingनिश्चित रूप से उस समय ( यहां से विचार ) के यूनिक्स पर दुरुपयोग कर सकते हैं । 

DO print("4 8 15 16 23 42");system("ping 1.0 -c1 -w6240>/dev/null")OD
— बिल्ली
स्रोत
1
यह चालाकी है! आप कह सकते हैं कि कार्यक्रम "स्लीप-पिंग" है। : पी
— DJMcMayhem
@DrGreenEggsandIronMan हा!
— बिल्ली
@DrGreenEggsandIronMan कहां systemऔर कहां ठीक नहीं है के लिए लाइन है? आप ठीक हैं, system("ping ...")लेकिन चुनौती कहती है कि मैं systemC से उदाहरण के लिए bash कमांड का उपयोग नहीं कर सकता । ALGOL प्रिंटिंग कर रहा है, लेकिन मेरे पास सोने के अलावा ping(8)या कोई दूसरा रास्ता नहीं है sleep(1)।
— बिल्ली
खैर, जब मैंने चुनौती लिखी, मैंने गुगली की और देखा कि 89 में बैश निकला था, इसलिए मैंने सोचा कि "का उपयोग करना धोखा है!"। मुझे लगता है कि बड़ा मुद्दा यह है कि system("sleep")उस समय से एक ओएस पर काम करेगा या नहीं । मैं पोस्ट को संपादित करूँगा।
— DJMcMayhem
1
मुझे नहीं लगता कि एनसीपी के लिए पिंग था। 80 के दशक की शुरुआत तक इंटरनेट ने टीसीपी / आईपी में परिवर्तन नहीं किया था, और ICMP इको रिक्वेस्ट का पहला उल्लेख RFC777, अप्रैल 1981 को हुआ था।
— नंजलज
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.