109

आपको एक प्रोग्राम लिखना है जो सोर्स कोड को आउटपुट करेगा

मूल कार्यक्रम से बड़ा (चरित्र वार)
दूसरे प्रोग्राम को चलाने पर खुद से बड़ा प्रिंट करेगा (यानी नया प्रोग्राम भी इस चुनौती का एक वैध जवाब है)

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

code-golf quine code-generation

— PyRulez
स्रोत

4

@ केविन, परिभाषा पुनरावर्ती है। आउटपुट एक प्रोग्राम होना चाहिए जिसका आउटपुट खुद से बड़ा हो, और इस सवाल का जवाब हो। तो आउटपुट का आउटपुट आउटपुट से बड़ा होना चाहिए, और आउटपुट का आउटपुट आउटपुट भी बड़ा होना चाहिए, आदि

— ugoren

8

मुझे लगता है कि आपको अपने नियमों को स्पष्ट करना चाहिए। एक तरफ, इस तरह के कार्यक्रम द्वारा किसी भी अतिरिक्त कोड आउटपुट "स्पष्ट रूप से बेकार" है; दूसरी ओर, आउटपुट में सभी अतिरिक्त कोड "उपयोगी" हैं, जिसमें यह इस चुनौती का जवाब देने के लक्ष्य को पूरा करता है।

— जेसन सी

5

अपनी चुनौती को नष्ट करने के लिए क्षमा करें। :^)

— जस्टिन

2

मुझे लगता है कि यह चुनौती एक कोड गोल्फ की तुलना में एक लोकप्रियता प्रतियोगिता के रूप में बहुत बेहतर होगी। यह एक बहुत अधिक रचनात्मकता के लिए अनुमति देगा!

— corsiKa

30

स्वाभाविक रूप से, इस तरह के कार्यक्रम को एक कुनैन के रूप में जाना जाना चाहिए।

— जोनाथन वान मैट्रे

89

GS2 (8636bd8e) , 0 बाइट्स

यह एक सिंगल न्यूलाइन को प्रिंट करता है, जो दो न्यूलाइन को प्रिंट करता है, जो तीन न्यूलाइन को प्रिंट करता है, एट सेटेरा।

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

— डेनिस
स्रोत

3

क्या यह तकनीकी रूप से गैर-प्रतिस्पर्धा नहीं है क्योंकि gs2 चुनौती से नया है?

— DJMcMayhem

24

यह कमेटी डेढ़ महीने तक चुनौती देती है। मैंने अभी इसका परीक्षण किया है, और यह इरादा के अनुसार काम करता है।

— डेनिस

1

कैसे यह एक बचाव का रास्ता नहीं है ???

— मामा फन रोल

14

@MamaFunRoll ऐसा क्यों होगा? यह एक खाली रेटिना प्रोग्राम प्रिंटिंग 1 , एक खाली जैली प्रोग्राम प्रिंटिंग 0 , या एक खाली अटक प्रोग्राम प्रिंटिंग हैलो, वर्ल्ड से अलग नहीं है! ।

— डेनिस

2

@ यह केवल ऐसा होता है कि एक newline GS2 में एक और नई लाइन आउटपुट करता है।

— फल तोड़ना

299

एच 9 + : 1 चार

ये सही है। एक पात्र। बोल को 99 बोतल बीयर में आउटपुट करता है , जो एक वैध कार्यक्रम है। सभी बाहरी डेटा की गिनती नहीं है, लेकिन वहाँ बहुत सारे हैं 9।

आउटपुट प्रोग्राम के आउटपुट में 59 बार बीयर की 99 बोतल के बोल हैं।

यदि आप प्रोग्राम nटाइम चलाते हैं (यदि मेरा कैलकुलेशन सही है)

f(n) = 59^n-1

— जस्टिन
स्रोत

32

किसी दिए गए भाषा में 0 वर्ण प्रोग्राम, यह देखते हुए कि यह मान्य है, संभवतः 0 वर्णों का आउटपुट होगा। और किसी भी परिमित मूल्य x के लिए 0 * x = 0 के बाद से, मैं दावा कर सकता हूं कि मेरा आउटपुट प्रोग्राम वास्तव में स्रोत कोड की तुलना में 9999999999999999 गुना बड़ा है।

— नाइट्रो 2k01

39

@JohannesH। सभी (हल करने योग्य) समस्याओं के लिए एक प्रोग्रामिंग भाषा मौजूद है जो 0 वर्णों में समस्या को हल करती है।

— क्राइकर

15

मैं अभी भी स्थानांतरित करता हूं कि हम उस "क्रंचर के प्रमेय" का नाम लेते हैं, जब तक कि यह पहले से ही पता न चला हो।

— Erty Seidohl

22

एक दिलचस्प विशेषता यह है कि इसमें 2*59^n-2"हैलो", "इन" के कारण "हैलो, दुनिया!" के उदाहरण भी होंगे ।

— AJMansfield

8

लगता है कि आप हरा चुके हैं।

— पायरुलेज़

118

GolfScript, 9 वर्ण

{.'.~'}.~

यह कोड आउटपुट:

{.'.~'}{.'.~'}.~

कौन से आउटपुट:

{.'.~'}{.'.~'}{.'.~'}.~

कौन से आउटपुट:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

और इसी तरह।

मेरा मानना है कि यह "वास्तविक" ट्यूरिंग-पूर्ण प्रोग्रामिंग भाषा में अब तक का सबसे छोटा उत्तर है।

स्पष्टीकरण:

मूल रूप से, ऊपर दिया गया मूल कोड एक "क्वीन-लेयर" है: यह सामान्य क्वीन का उत्पादन करता है और उसके बाद होता है।

GolfScript में, किसी भी कोड ब्लॉक शाब्दिक (जैसे {foo}), यदि स्टैक पर undisturbed छोड़ दिया जाता है, तो वह एक क्वीन है। इस प्रकार, अपने दम पर, {.'.~'}बस खुद को आउटपुट करता है, बस किसी भी अन्य कोड ब्लॉक की तरह।

.~कोड के अंत में स्टैक पर पिछले कोड ब्लॉक लेता है, यह डुप्लिकेट, और प्रतिलिपि निष्पादित करता है। जब निष्पादित किया जाता है, तो कोड .'.~'ब्लॉक के अंदर कोड स्टैक पर सबसे ऊपरी आइटम (यानी स्वयं की प्रतिलिपि) को डुप्लिकेट करता है और स्ट्रिंग को जोड़ता है .~।

कार्यक्रम के अंत में, GolfScript दुभाषिया स्ट्रिंग पर सब कुछ स्ट्रिंग और आउटपुट करता है, जो इस मामले {.'.~'}में, इनपुट की तुलना में एक से अधिक ब्लॉक होते हैं , साथ ही स्ट्रिंग .~।

बोनस:

]पहले से पहले जोड़ना .(स्टैक पर सभी कोड ब्लॉक को एक डुप्लिकेट करने से पहले एक सरणी में इकट्ठा करना) यह तेजी से बढ़ता है:

{].'.~'}.~

आउटपुट:

{].'.~'}{].'.~'}.~

कौन से आउटपुट:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

कौन से आउटपुट:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

और इसी तरह।

— इल्मरी करोनें
स्रोत

196

{].'.~'}.~︵ ┻━┻

— नाइट्रो 2k01

2

bit.ly/1cQXJyA

— जेसन सी

2

@ nitro2k01 मेरे पहले विचार बिल्कुल: D

— सोंगो

1

"वास्तविक" उद्धरण में है क्योंकि HQ9 + वास्तविक नहीं है या क्योंकि गोल्फस्क्रिप्ट वास्तविक नहीं है, या दोनों?

— रोजर पटे

1

@thepiercingarrow स्रोत कोड इस से

— रॉड

108

जावा 7: 0 चार्ट

फ़ाइल के रूप में सहेजें Blank.java। यदि आप इसे किसी अन्य फ़ाइल के रूप में सहेजते हैं, तो किसी भी उदाहरण Blankको उपयुक्त फ़ाइल नाम से बदलें ।

फिर, पहले संकलन के माध्यम से कमांड लाइन में चलाएं, फिर चल रहा है। यदि संकलन विफल रहता है, तो रोकें।

मैं इसे जावा 7 के रूप में सूचीबद्ध करता हूं क्योंकि यह जावा के विभिन्न संस्करणों के लिए अलग-अलग उत्पादन कर सकता है।

पहले कुछ आउटपुट (stderr के लिए आउटपुट):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

— जस्टिन
स्रोत

23

"आप एक प्रोग्राम लिखेंगे जो सोर्स कोड को आउटपुट करेगा ।" आउटपुट यकीनन सोर्स कोड नहीं है। और इसके अलावा, आउटपुट की परिभाषा पर निर्भर करता है (चाहे आउटपुट विशेष रूप से आना चाहिए stdout) वास्तव में आउटपुट कुछ भी नहीं है।

— नाइट्रो 2k01

43

@ nitro2k01 मैं उसी को उद्धृत करता हूं: "आप एक प्रोग्राम लिखने के लिए हैं जो स्रोत कोड आउटपुट करेंगे "। कुछ भी सोर्स कोड है। लेकिन केवल कुछ चीजें वैध स्रोत कोड हैं। इसके अतिरिक्त, यह निर्दिष्ट नहीं किया गया था कि आउटपुट क्या माना जाता है, इसलिए मुझे वहां स्वतंत्रता की अनुमति है।

— जस्टिन

15

@PyRulez यह सही है। मैंने तुम्हारे नियमों का शोषण किया। आपको इस उत्तर को स्वीकार करने की आवश्यकता नहीं है। जब मैंने यह पोस्ट किया, तो मुझे पता था कि एक विवाद कई अप और डाउन वोटों के साथ पूरा होगा। मैंने फैसला किया कि यह इसके लायक होगा, हालांकि।

— जस्टिन

29

क्या आप सुनिश्चित हैं कि प्रोग्राम ने ही आउटपुट प्रिंट किया है? यह केवल संकलक नहीं था? कार्यक्रम कभी संकलित नहीं किया जाता है और खुद की व्याख्या नहीं की जाती है और न ही निष्पादित किया जाता है, इस प्रकार यह किसी भी आउटपुट का उत्पादन करने में सक्षम नहीं था।

— VX

12

@ blabla999 मैं असहमत हूं - लोग इन चुनौतियों की कोशिश नहीं करते हैं क्योंकि कोई और कुछ पागल करता है। हम सिर्फ खुद को चुनौती देते हैं कि वह इसे किसी और तरह से करे। जैसा कि मार्क रोसेवाटर कहते हैं, "प्रतिबंध नस्ल रचनात्मकता"

— corsiKa

79

HQ9 +, HQ9 ++ और सिमिलर, 2 वर्ण

QQ

यह आउटपुट है:

QQQQ

— विक्टर स्टैफ़ुसा
स्रोत

36

मैंने यह देखा और सोचा "ओह नहीं, यह कुछ भी नहीं हरा सकता है।" मैं किसी चीज के साथ आने की कोशिश करने लगा, फिर उसने मुझे मारा। तो मैंने एक उत्तर पोस्ट किया।

— जस्टिन

1

@Quincunx ब्रावो ने आपके जवाब को गलत ठहराया।

— विक्टर स्टाफ़ुसा

4

@Quincunx नहीं, मुझे लगता है कि यह वह जगह है 2^2^n, जहां शुरुआती कार्यक्रम पीढ़ी 0. लंबाई की पुनरावृत्ति होती है m -> m^2।

— वोर्टिको

3

@Vortico अच्छा बिंदु। हालांकि मैंने इसे गलत कहा था, मेरा मतलब था: कोड-लंबाई पर n, आउटपुट बन जाता है n^n। हालाँकि, यह गलत है; जब कोड-लंबाई होती है n, तो आउटपुट की लंबाई होती हैn^2

— जस्टिन

2

हालांकि यह हास्यास्पद है क्योंकि पहले दो पुनरावृत्तियों भी इस सवाल के संभावित दावेदार हैं।

— पायरुलेज

29

रूबी २ 27

इसका (इसके माध्यम से ) थोड़ा बहुत संशोधित संस्करण :

puts <<3*3,3
puts <<3*3,3
3

जितनी बार putsप्रिंट होती है , उतनी बार तेजी से बढ़ती है।

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

— daniero
स्रोत

17

कैसर चीफों से प्रेरित उत्तर

— बेन जैक्सन

25

लैम्ब्डा कैलकुलस - 29

एक साधारण लंबोदर शब्द

(λu.(u u)(u u))(λu.(u u)(u u))

एक बीटा कमी पैदावार द्वारा इस शब्द को कम करना

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

और आगे और आगे। यह क्लासिक पर एक साधारण संस्करण है (λu.u u)(λu.u u)जो लैम्ब्डा कैलकुलस में एक क्वीन है, यहां डबल सेल्फ एप्लिकेशन का मतलब है कि हम दो बार आउटपुट प्राप्त करते हैं।

— jozefg
स्रोत

7

मैं तर्क दूंगा कि लैम्ब्डा कैलकुलस में, लैम्बडा शब्द का "रनिंग" का अर्थ है, अपने सामान्य रूप की गणना करना, एक एकल बीटा कमी का प्रदर्शन नहीं करना। इसके अलावा, एक शब्द में कई रिडेक्स हो सकते हैं, इसलिए "सिंगल रिडेक्स को कम करना" एक अस्पष्ट ऑपरेशन है।

— पेट्र पुडलक

2

आप सही कह रहे हैं, लेकिन चूंकि इस शब्द का कोई सामान्य रूप नहीं है, इसलिए छोटे चरण में कमी के संदर्भ में इस बारे में बात करना समझ में आता है। चूंकि लैम्ब्डा कैलकुलस में किसी भी अंतर्निहित सेट मूल्यांकन का अभाव है, इसलिए मैं कॉल-बाय-नेम शब्दार्थ संख्या नहीं के साथ एक एकल रेडेक्स शीर्ष स्तर रिडेक्स को कम करने के लिए "रनिंग" को परिभाषित कर सकता हूं ?

— जोजफग

3

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

— पेट्र पुडल्क

2

(λx.xxx) (λx.xxx): २०

— फेबियो एफ।

2

(λx। xx) (λx। xxx) एक सिंगल स्टेप में उसको कम करता है

— बेन मिलवुड

23

एसएच स्क्रिप्ट, 9

cat $0 $0

घातीय दर से बढ़ता है।

या तो चलाने के रूप में sh whatever.shया इसे निष्पादन योग्य के रूप में सेट करें।

विंडोज संस्करण यहाँ है ।

— जेसन सी
स्रोत

2

मेरे द्वारा यह टिप्पणी लिखने के समय, क्वीन विकी पेज का कहना है कि फाइलसिस्टम से पढ़ना धोखा है।

— भगवान राते te

3

@ LordRatte दूसरी ओर, चुनौती एक रानी लिखने के लिए नहीं था।

— जेसन सी

20

डीसी 11

काफी सरल:

6579792
dfP

पहली पंक्ति को एक बार हर पीढ़ी में दोहराया जाता है:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

अंतिम पंक्ति में निम्नलिखित निर्देश होते हैं: dस्टैक (6579792) पर लगाए गए अंतिम मान को डुप्लिकेट करता है (ताकि हम हर बार इसे चलाते समय एक और कॉपी प्राप्त करें), fपूरे स्टैक को प्रिंट करता है (जो उसी संख्या का एक गुच्छा है) और Pसंख्या (6579792) को बाइट स्ट्रीम के रूप में प्रिंट करता है, जो कि प्रदर्शित करता है dfP।

— daniero
स्रोत

16

Redcode (पुनरावर्ती समाधान)

यह रेडकोड में सबसे आसान योद्धा के योग्य कोड है , प्रसिद्ध छोटा सा भूत:

MOV 0, 1

जब निष्पादित किया जाता है, तो कोड स्मृति में अगले पते पर अपने एकल निर्देश की एक प्रति लिखता है; फिर इसे निष्पादित करता है, आदि।

— थॉमस बरुचेल
स्रोत

15

पायथन 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

इसे एकल वर्ण फ़ाइल नाम के साथ __ file__ को बदलकर और फ़ाइल को सहेजने के रूप में छोटा किया जा सकता है, लेकिन मुझे लगा कि यह उत्तर प्रश्न की भावना में अधिक था। एक पुनरावृत्ति के बाद यह आउटपुट:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

— user1547129
स्रोत

3

यह एक रानी नहीं है। परिभाषा देखें ।

— पेट्र पुडलक

14

@ पेट्रूडलाक नोर इस प्रश्न में कोई कार्यक्रम हैं। यह क्वीन-वेरिएंट समस्या है, सख्त क्वीनिंग नहीं।

— AJMansfield

6

स्मॉलटाक, 125 61 57

गोल्फ संस्करण लगभग अपठनीय दिखता है इसलिए मैं पहले समझाता हूं (और असली पहचानकर्ताओं का उपयोग करता हूं)।

यह "अजीब-से-से-उत्पादन-ए-स्टैक-ओवरफ्लो" आत्म संशोधन विधि का एक प्रकार है।

विधि एक हैलो संदेश और उसके वर्तमान स्रोत (केवल प्रदर्शन के लिए) को प्रिंट करती है। फिर, कोड को एक लंबी स्ट्रिंग और इंस्टॉल करने के लिए संशोधित किया गया है। अंत में, नए कोड को पुनरावर्ती कहा जाता है।

तत्काल भागने से खुद को बचाने के लिए, यह उपयोगकर्ता को प्रत्येक चक्र में पुष्टि करने देता है।

संकलन में वस्तु:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

किसी भी वस्तु को "eatMe_alice" भेजकर शो शुरू करें; शून्य करेगा:

nil eatMe_alice

एक अच्छा संस्करण नए कोड को पुनरावर्ती रूप से कॉल नहीं करना है, लेकिन इसके बजाय पुनरावृत्ति से, कॉल स्टैक को खोलना और नई विधि में पुन: दर्ज करना है। यह एक पुनरावृत्ति अपवाद के लिए अग्रणी नहीं होने का लाभ है। ऐसा करने के लिए, पुनरावर्ती कॉल ("सेल्फ ईमेम_लिस") को बदलें:

thisContext resend

गोल्फ:

जाहिर है, प्रिंटिंग और सेल्फ कॉलिंग के लिए नहीं कहा गया था, इसलिए सबसे छोटा (गोल्फ के लिए) केवल अपने स्वयं के स्रोत के लिए एक टिप्पणी संलग्न करना और उसे वापस करना है। साइड इफेक्ट के रूप में, यह अगले कॉल के लिए भी स्थापित हो जाता है ...

x|s|Object compile:(s:=thisContext method source,'""').^s

— blabla999
स्रोत

5

एसएच स्क्रिप्ट, 12 8 7

के साथ एक फ़ाइल स्टोर करें

sed p *

अपने स्वयं के, खाली निर्देशिका में और sh [file]निष्पादन योग्य का उपयोग करके या सेट करके इस निर्देशिका से चलते हैं ।

8 वर्णों वाला पुराना विकल्प , लेकिन इसकी अपनी निर्देशिका की आवश्यकता नहीं है। के साथ एक फ़ाइल स्टोर करें

sed p $0

और sh [file]निष्पादन योग्य सेट का उपयोग करके या चलाएं ।

12 अक्षरों वाला पुराना विकल्प :

sed -i- p $0

यह वास्तव में प्रोग्राम फ़ाइल में ही आउटपुट करेगा, लेकिन आउटपुट को निर्दिष्ट नहीं किया गया था। एक घातीय दर पर खुद को दोहराता है।

— जेन्स इरट
स्रोत

1

आप अभी भी मौका का उपयोग कर सकते हैं ed, अपने आदमी पृष्ठ के माध्यम से देखना नहीं चाहता था ...

— जेन्स इरेट

4

जावास्क्रिप्ट, 41 , 40 वर्ण

function f(){console.log(f+"f(f())")}f()

पहली बार जब आप इसे चलाते हैं तो यह ;f()अंत में दूसरे के साथ आउटपुट करता है । बाद में दो बार छपे प्रत्येक "इनपुट" स्रोत में आउटपुट के परिणाम मिलते हैं।

alertकी तुलना में कम होगा, console.logलेकिन मैं कई चेतावनी संवादों को आउटपुट के रूप में नहीं मानता हूं, जबकि कंसोल में कई लाइनों को आउटपुट के रूप में कॉल करना उचित लगता है।

— DocMax
स्रोत

आप एक बाइट "f(f())""f();f()"

— हेडी

यह मेरे लिए काम करने के लिए प्रतीत नहीं होता ...

— विनाशकारी नींबू

4

जे , 1 बाइट

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

खुली बोली, स्पष्ट रूप से, खुली बोली त्रुटि देती है:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

ध्यान दें कि, जे इंटरप्रेटर की प्रकृति से, त्रुटियों को STDOUT में मुद्रित किया जाता है , STDERR को नहीं।

जब ऊपर कोड के रूप में चलाया जाता है, तो यह प्रिंट करता है:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

फिर

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

और इसी तरह। जितनी बार कोड चलता है, दूसरी पंक्ति चार बाइट्स के साथ बाईं-पैडेड होती है | , इस चुनौती की आवश्यकता को पूरा करती है।

जे , उचित रानी संस्करण, 25 बाइट्स

echo,~'echo,:~(,quote)'''

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

आउटपुट

echo,:~(,quote)'echo,:~(,quote)'

और फिर यह खुद को दो बार अलग लाइनों पर आउटपुट करता है:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

फिर

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

और इसी तरह।

पहला आउटपुट मानक J quine का एक सरल संस्करण है । जोड़ा ,:~खुद को लंबवत रूप से जोड़ता है, जहां परिणामस्वरूप 2 डी सरणी एक ही स्ट्रिंग की दो पंक्तियों के रूप में मुद्रित होती है।

— bubbler
स्रोत

3

विंडोज .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

घातीय दर से बढ़ता है।

यहाँ समतुल्य एसएच संस्करण ।

— जेसन सी
स्रोत

3

रेटिक्यूलर, 11 बाइट्स, नॉन-कंपेटिंग

"'34'coo1o;

यह मानक क्वीन फ्रेमवर्क है, सिवाय इसके कि 1प्रत्येक पुनरावृत्ति के बाद एक अतिरिक्त प्रिंट किया जाता है। इसे ऑनलाइन आज़माएं!

पहले कुछ आउटपुट:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

— कोनोर ओ ब्रायन
स्रोत

3

माइक्रोसेप्टिक II, 6 बाइट्स

नॉनकोमपेटिंग, भाषा चुनौती को स्थगित कर देती है।

"qp"qp

पहला पुनरावृत्ति qpअंत में एक अतिरिक्त जोड़ता है , और प्रत्येक क्रमिक पुनरावृत्ति शुरुआत में इस मूल कार्यक्रम की एक अतिरिक्त प्रतिलिपि जोड़ता है।

— SuperJedi224
स्रोत

3

रूनिक एनकाउंटर , 6 बाइट्स

"'<S@>

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

यह एक अजीब था। जो मुझे करना था ~, वह जो किंग द्वारा मिली मूल रानी से हटा दिया गया था ।

हर अतिरिक्त रन <अंत में एक और जोड़ता है , जैसे:

"'<S@><<<<<<<<<

जिनमें से सभी कुछ नहीं करते हैं।

— Draco18s
स्रोत

2

एक्मास्क्रिप्ट 6 (51 बाइट्स):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

यह स्वयं का एक लंबा संस्करण तैयार करता है, जो स्वयं का एक लंबा संस्करण उत्पन्न कर सकता है, जो स्वयं का एक लंबा संस्करण उत्पन्न कर सकता है, आदि ...

— टूथब्रश
स्रोत

2

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

यह प्रत्येक रन पर एक अर्धविराम जोड़ देगा।

— ComFreek
स्रोत

क्या अर्धविराम बेकार कोड हैं?

— जस्टिन

3

@Quincunx वे हैं, आप सही हैं। हालाँकि, आप उपयोगी कोड पर क्या विचार करेंगे?

— 18

शायद आप अंदर डाल सकते हैं ';'। तब आपको अधिक आउटपुट मिलेंगे।

— जस्टिन

1

क्यों नहीं <?=fgets(fopen(__FILE__,'r')).';';?

— इस्माईल मिगुएल

1

;<?echo fgets(fopen(__FILE__,'r'));

— jimmy23013

2

ECMAScript 6 (38 वर्ण)

(f=_=>'(f='+f+')();(f='+f+')();')();

कौन से आउटपुट:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

संपादित करें

आप कर सकते हैं (28 अक्षर):

(f=_=>'(f='+f+')();'+f())();

हालाँकि यह असीम रूप से पुनर्जीवित होगा और कभी भी कुछ भी नहीं लौटाएगा ... लेकिन इसे कुछ इस तरह से किया जा सकता है (42 अक्षर):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

जो आउटपुट देगा:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

— MT0
स्रोत

3

+_+ =_=इमोटिकॉन्स के लिए +1

— TuxCrafting

2

आम लिस्प, 16 वर्ण

(print `(or ,-))

दी, यह इंटरेक्टिव-ओनली है, लेकिन मौजूदा टॉप-लेवल फॉर्म को रेफर करने में सक्षम होने के कारण यह संभव है कि स्पेसिफिकेशंस को पूरा करने वाले नॉन-ट्रिवियल प्रोग्राम को कम से कम किया जाए।

क्या वास्तव में दिलचस्प होगा जो सबसे तेजी से चल रहा है। शायद कुछ ऐसा

(print `(progn ,@(loop repeat (length -) collect -)))

— स्टुअर्ट ऑलसेन
स्रोत

आम लिस्प के लिए +1। मुझे लगता है जैसे आप छोड़ सकते हैं `और ,?

— डेनिएरो

@daniero उद्धरण के बिना, यह सिर्फ मूल कार्यक्रम को प्रिंट करता है, कभी नहीं बढ़ रहा है। उस बिंदु पर, आप साथ ही साथ छोड़ सकते हैं or, भी:(print -)

— स्टुअर्ट ऑलसेन

2

जूलिया, 66 वर्ण

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

आउटपुट (134 वर्ण):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

परिणाम निष्पादित करने का परिणाम (268 वर्ण):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

अगला परिणाम (536 वर्ण):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

अगला परिणाम (1072 वर्ण):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

मुझे उम्मीद है कि यह नियमों के अनुसार होगा।

यह बड़े आउटपुट का उत्पादन करता है, और आउटपुट स्वयं मान्य स्रोत कोड है जो फिर से बड़े आउटपुट का उत्पादन करता है।

— एमएल
स्रोत

क्या आउटपुट, जब दौड़ा जाएगा, एक वैध प्रविष्टि का उत्पादन?

— PyRulez

पहले उदाहरण में आउटपुट मान्य कोड है। यह एक स्ट्रिंग शाब्दिक है जिसमें 5 अवधियाँ हैं। दूसरे उदाहरण में, जूलिया प्रॉम्प्ट में प्रवेश करने से खुद कुछ नहीं होगा। मैंने अभी सोचा था कि बस एक हिट करने से उत्तर वास्तव में एक नया चरित्र देता है जो इनपुट की तुलना में लंबा आउटपुट देता है।

— एमएल

क्या "....." स्वयं का एक बड़ा संस्करण तैयार करेगा?

— PyRulez

आह, अब मैं समझ गया। मैंने अभी देखा कि इसे पुनरावर्ती होना चाहिए ... मेरे समाधान को सही करने का समय। संकेत के लिए धन्यवाद।

— एमएल

1

मुझे लगता है कि कोड अब नियमों के अनुसार है।

— ML

2

05AB1E, 15 बाइट्स, नॉनकंपेटिंग

0"DÐ34çý"DÐ34çý

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

प्रिंटों 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
जो प्रिंट 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
आदि

— ओलिवर नी
स्रोत

दोनों उदाहरणों को DDप्रतिस्थापित किया जा सकता है Ð।

— एमिगा

1

क्यों नॉनकंपेटिंग?

— एमडी एक्सएफ

2

एवोलोप, 9 × 9 आयत (81 सेल)

Evoloop सेलुलर automaton गोली के साथ शामिल पैटर्न जो अपने आपको "Quine की तरह" रास्ते में दोहराने का समर्थन करता है। विशेष रूप से, इन पैटर्नों में प्रत्येक में एक "प्रोग्राम" होता है; एक पैटर्न पहले कार्यक्रम को निष्पादित करके (जो बेटी का "शरीर" बनाता है) और फिर बेटी में कार्यक्रम की नकल करके खुद को पुन: पेश करता है।

उपरोक्त अधिक प्रसिद्ध "लैंग्टन लूप्स" सेलुलर ऑटोमोबोन के साथ-साथ इवोलोप पर भी लागू होता है, लेकिन एवोलोप में एक दिलचस्प अंतर है, जो यह है कि एक पैटर्न बनाना आसान है जो प्रत्येक क्रमिक पीढ़ी में बढ़ता है।

(बहुत अधिक दिलचस्प है, मेरी राय में, यह तथ्य यह है कि एवोलोप एक साधारण सेलुलर ऑटोमेटोन है जिसमें ऐसे पैटर्न होते हैं जो खुद को पुन: पेश करते हैं और बहुत ही जीवन की तरह से विकसित होते हैं! मुझे लगता है कि एकमात्र ज्ञात सेलुलर ऑटोमेटा है जो ऐसा करते हैं जो इवोलोप और इसके वंशज हैं। , हालांकि, इवोलोप की कमी यह है कि एक विशेष "सर्वश्रेष्ठ" जीनोम है; विकास हमेशा अंततः इस एक जीनोम में परिवर्तित होता है।)

अब, इस सबमिशन में दो कमियाँ हैं। एक यह है कि यह स्पष्ट नहीं है कि सेलुलर ऑटोमेटन का "आउटपुट" क्या है। लेकिन मुझे लगता है कि एक स्व-प्रजनन करने वाला ऑटोमेटन एक क्वीन होने के लिए "करीब करीब" है; यह निश्चित रूप से कम दिलचस्प नहीं है! दूसरी कमी यह है कि ये पैटर्न केवल खुद की एक प्रति नहीं बनाते हैं; मूल प्रति की प्रत्येक प्रति अनंत रूप से स्वयं की कई प्रतियां बनाने का प्रयास करती है, और ये प्रतियाँ एक दूसरे के साथ विनाशकारी तरीके से अंत होती हैं। इसलिए, मुझे लगता है कि मैंने इस चुनौती की आवश्यकताओं को आत्मा में पूरा किया है, लेकिन पत्र में नहीं।

आगे की हलचल के बिना, पैटर्न है:

यहाँ एक पैटर्न फिर से है, एक प्रारूप में जिसे कॉपी किया जा सकता है और उसे Golly में पेस्ट किया जा सकता है:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

ठीक है, लेकिन यह कैसा दिखता है? यह इस तरह दिख रहा है:

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

— टान्नर स्विट
स्रोत

1

बैच, २६

इस कोड को किसी भी .bat फ़ाइल में रखें और यह निष्पादित (अनंत लूप में) जारी रहेगा और फ़ाइल भी बढ़ेगी।

echo echo %0 ^>^> %0 >> %0

— ub3rst4r
स्रोत

यह काफी काम नहीं करता है, %0क्या स्क्रिप्ट का उपयोग करने के लिए कमांड का उपयोग किया जाता है, जिसमें .BATविस्तार नहीं हो सकता है । आप %~nx0बैच फ़ाइल का पूरा फ़ाइल नाम प्राप्त करने के लिए उपयोग कर सकते हैं ।

— जेसन सी

@ जेसन AFAIK, इसे .batनिष्पादित करने की आवश्यकता नहीं है । यदि फ़ाइल नाम है execute.bat, तो आप executeया तो दर्ज कर सकते हैं या execute.bat। दोनों काम करेंगे।

— ub3rst4r

फ़ाइल अपने आप में एक की जरूरत है .batनिष्पादित करने के लिए विस्तार, लेकिन आप एक्सटेंशन बंद छोड़ सकते हैं जब आप इसे निष्पादित (जब आप कोई एक्सटेंशन के साथ एक आदेश लिखें, विंडोज की कोशिश करता है .com, .exeहै, तो .batइसी क्रम में)। यदि फ़ाइल नाम है hello.bat, तो >> %0नाम की एक फ़ाइल लिखेंगे hello, जो मूल नहीं है hello.bat(और निष्पादित नहीं किया जा सकता है)।

— जेसन सी

1

पीवाईजी (6)

P(Q,Q)

प्रिंट्स यह स्वयं का सोर्स कोड है, जिसे न्यूलाइन्स द्वारा अलग किया गया है। दूसरी पीढ़ी होगी

P(Q,Q)
P(Q,Q)

इत्यादि।

— ɐɔıʇǝɥʇuʎs
स्रोत

1

ओआईएल , 83 बाइट्स

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

— L3viathan
स्रोत

1

मदद, WarDoq! , 1 बाइट।

एच

प्रिंट करता है Hello, World!।

एच के अलावा अन्य वर्ण वैध (और सुरक्षित) स्रोत कोड हैं (जो हैलो वर्ल्ड के अन्य वेरिएंट को प्रिंट करते हैं)।

— n4melyh4xor
स्रोत

इसके अलावा HQ9 + के (वेरिएंट) में काम करता है।

— कैलक्यूलेटरफनलीन

HQ9 में @CalculatorFeline + यह बढ़ना जारी नहीं रखेगा।

— मार्टिन एंडर

प्रोग्राम जो स्वयं के बड़े संस्करण बनाता है (क्वीन-वैरिएंट)

GS2 (8636bd8e) , 0 बाइट्स

एच 9 + : 1 चार

GolfScript, 9 वर्ण

स्पष्टीकरण:

बोनस:

जावा 7: 0 चार्ट

HQ9 +, HQ9 ++ और सिमिलर, 2 वर्ण

रूबी २ 27

लैम्ब्डा कैलकुलस - 29

एसएच स्क्रिप्ट, 9

डीसी 11

Redcode (पुनरावर्ती समाधान)

पायथन 3 - 55

स्मॉलटाक, 125 61 57

एसएच स्क्रिप्ट, 12 8 7

जावास्क्रिप्ट, 41 , 40 वर्ण

जे , 1 बाइट

जे , उचित रानी संस्करण, 25 बाइट्स

विंडोज .BAT, 25

रेटिक्यूलर, 11 बाइट्स, नॉन-कंपेटिंग

माइक्रोसेप्टिक II, 6 बाइट्स

रूनिक एनकाउंटर , 6 बाइट्स

एक्मास्क्रिप्ट 6 (51 बाइट्स):

PHP, 38

आम लिस्प, 16 वर्ण

जूलिया, 66 वर्ण

05AB1E, 15 बाइट्स, नॉनकंपेटिंग

एवोलोप, 9 × 9 आयत (81 सेल)

बैच, २६

पीवाईजी (6)

ओआईएल , 83 बाइट्स

मदद, WarDoq! , 1 बाइट।