ए लाइन ऑन ए क्विन


30

आपका लक्ष्य एक ऐसा कार्यक्रम बनाना है जो प्रत्येक के बाद एक नई रेखा के साथ, अनिश्चित काल तक खुद को प्रिंट करता है। इस प्रकार, यदि आपका प्रोग्राम वन-लाइनर है, तो इसे आउटपुट की हर लाइन पर दोहराया जाएगा।

उदाहरण

कार्यक्रम:

A

आउटपुट:

A
A
A
...

नियम

  • यह एक संपूर्ण कार्यक्रम होना चाहिए, स्निपेट या फ़ंक्शन नहीं।
  • कार्यक्रम को स्टैक-ओवरफ्लो या पुनरावृत्ति सीमा त्रुटियों के बिना हमेशा के लिए लूप करना चाहिए।
  • आउटपुट स्टैडआउट या निकटतम विकल्प के लिए है।
  • कोई प्रोग्राम इनपुट स्वीकार नहीं किया जाता है।
  • मानक खामियों को अस्वीकार कर दिया जाता है, जैसे कि प्रोग्राम की फ़ाइल को खोलना या किसी बाहरी संसाधन तक पहुंचना। खाली कार्यक्रम एक मानक खामियों के रूप में अस्वीकृत हैं।
  • यदि आपका प्रोग्राम कोड एक अनुगामी न्यूलाइन के साथ समाप्त होता है, तो यह क्वाइन्स के बीच आवश्यक न्यूलाइन के रूप में नहीं गिना जाता है, और आपको एक और प्रिंट करना होगा।
  • - सबसे छोटा कोड जीतता है!

शीर्षक ऐसा लगता है कि केवल एक-लाइन प्रोग्राम योग्य हैं?
पाओलो एबरमन

@ Pa @loEbermann फिर समस्या वर्णन पढ़ें। यह एक अजीब शीर्षक है क्योंकि यह गाया जाता है। यहां एक मान्य मल्टी-लाइन प्रोग्राम का एक उदाहरण है: codegolf.stackexchange.com/a/57985/34718 । आप केवल शीर्षक पढ़कर एक चुनौती के बारे में सब कुछ जानने की उम्मीद नहीं कर सकते।
mbomb007

@ Pa @loEbermann यह सिर्फ है while(1)println(your_code);
मैथ्यू रोह

जवाबों:


19

विखंडन, 7 बाइट्स

'!+!NR"

मैंने अब तक जो सबसे छोटा विखंडन पाया है, उसका एक सरल संशोधन : मैं !इसके बजाय केवल गैर-विनाशकारी का उपयोग कर रहा हूं Oऔर Nनई रेखा के लिए जोड़ा गया ।

तो सब सब में, यहाँ है कि यह कैसे काम करता है: नियंत्रण प्रवाह Rएक दाएं-बाएं परमाणु के साथ शुरू होता है। "टॉगल स्ट्रिंग मोड, जिसका अर्थ है कि अगले "मुद्रित होने तक सब कुछ : इस मामले में '!+!NR। वह "और न्यूलाइन छपना छोड़ देता है । '!परमाणु के द्रव्यमान को 33 पर सेट करता है, +इसे 34 (वर्ण कोड ") तक बढ़ाता है और !उद्धरण प्रिंट करता है। Nएक नई Rरेखा प्रिंट करता है, और अब इस मामले में एक सेशन नहीं है, इसलिए लूप शुरू हो जाता है।

निम्नलिखित 7-बाइट समाधान भी काम करता है:

"NR'!+!

9

> <> , 16 बाइट्स

'ard3*o50l2)?.~~

पारंपरिक> <> क्वीन बहुत अधिक oएस का उपयोग करता है , इसलिए हम मुद्रण के लिए एक लूप का उपयोग करते हैं। प्रत्येक कूदने से पहले हम 5 और 0 (जहां से कूदना है, वहां के निर्देशांक) को धक्का देते हैं, जिसके बाद हम या तो कूदते हैं .यदि प्रिंट करने के लिए अभी भी कुछ है, या शीर्ष दो मानों को पॉप करता है ~~

(स्टैक ओवरफ्लो नियम के बारे में भूल जाने के बाद से मैं 16 संस्करण पर लौट आया।)


एक विकल्प है "ar00go50l2)?.[, है ना?
mbomb007

3
@ mbomb007 मुझे लगता है, लेकिन मैं d3*तब से पसंद कर रहा हूं जब आप gअपना खुद का सोर्स कोड
पढ़ते हैं

8

सीजेएम, 13 बाइट्स

{_o"_g
"o1}_g

कार्यक्रम समाप्त होने से पहले ऑनलाइन दुभाषिया कुछ भी प्रिंट नहीं करता है, इसलिए आपको जावा दुभाषिया में इसका परीक्षण करना होगा।

व्याख्या

अंत में एक सामान्यीकृत सीजेम क्वीन जो अंत नहीं है _~

{_o"_g
"o1}

यह बस एक ब्लॉक धक्का देता है। _gब्लॉक को डुप्लिकेट करता है और इसे बार-बार निष्पादित करता है जबकि स्टैक के शीर्ष सत्य है (शर्त को छोड़ना)।

अब ब्लॉक के अंदर, ब्लॉक की दूसरी प्रति अभी भी स्टैक पर है। हम इसकी नकल करते हैं और इसके साथ प्रिंट करते हैं _oऔर फिर हम प्रिंट करते हैं _gजिसके बाद एक नई लाइन (क्विन के बीच आवश्यक अतिरिक्त न्यूलाइन) होती है "_g\n"o। अंत में हम 1लूप को दोहराने के लिए स्टैक पर एक धक्का देते हैं , क्योंकि दुर्भाग्य से, ब्लॉक सीजेएम में सत्य (या झूठी) नहीं हैं।


7

अजगर 2, 39

पाइथन में बहुत दिलचस्प काम नहीं है क्योंकि एक सामान्य कुनैन में लूप को जोड़ना तुच्छ है।

c='while 2:print"c=%r;exec c"%c';exec c

क्या यह स्टैक नहीं उड़ाता है?
जेसन फाफॉन

1
@JesanFafon नहीं, अगर आपने इसे आज़माया तो आप देखेंगे कि ऐसा नहीं है। कोई पुनरावृत्ति नहीं है।
21

6

पर्ल 5.10+, 40 37 बाइट्स

$_=q{say"\$_=q{$_};eval"while 1};eval

या (भी 37 बाइट्स)

$_=q{{say"\$_=q{$_};eval";redo}};eval

-M5.010या -Eकमांड लाइन ध्वज के साथ आह्वान करें , जैसे

$ perl -E '$_=q{say"\$_=q{$_};eval"while 1};eval'
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
...

मेरे मूल समाधान से 3 बाइट्स को हटाने के लिए इल्मरी करोनन का धन्यवाद , जो था:

eval while$_=q{say"eval while\$_=q{$_}"}

यह, साथ ही साथ छोटे 37-बाइट समाधान, निम्नलिखित क्वीन के सभी सरल रूप हैं, जिन्हें मैंने पहली बार इल्मरी के अन्य पदों में से एक में देखा था :

$_=q{say"\$_=q{$_};eval"};eval

चूँकि मैंने अपने मूल समाधान में एक whileलूप जोड़ा था , वह वास्तव में अधिकांश क्रेडिट का हकदार था। :-)


अच्छा है, और क्रेडिट के लिए धन्यवाद। :-) मूल क्वीन मेरा अपना डिज़ाइन है, हालाँकि किसी और ने अच्छी तरह से स्वतंत्र रूप से इसकी खोज की होगी। BTW, $_=q{say"\$_=q{$_};eval"while 1};evalया $_=q{{say"\$_=q{$_};eval";redo}};evalकुछ बाइट्स कम होगी। ( $_=q{say"\$_=q{$_};eval";eval};evalअभी और भी कम होगा, लेकिन मुझे संदेह है कि यह अंततः स्टैक से बाहर निकल जाएगा ।)
इल्मरी करोनें

मैं उम्मीद कर रहा था कि आप दिखाएंगे! छोटे समाधान के लिए धन्यवाद, मुझे लगा कि आप कुछ बेहतर करेंगे; लेकिन मैं इससे तब उब गया था जब मैंने इसे उस उत्तर में देखा था जिससे मैं जुड़ा हुआ था, मुझे बस इसे स्वयं आज़माना था। :) ईमानदार होने के लिए, मैंने अभी भी अपने सिर को चारों ओर से नहीं लपेटा है, लेकिन अतिरिक्त जवाब मुझे देखने के लिए और अधिक देते हैं। मुझे यकीन नहीं था कि अगर आपने इसकी उत्पत्ति की, क्योंकि मैंने आपको इस पृष्ठ पर अब तक की सबसे छोटी नॉन-चीटिंग पर्ल क्वीन (~!) का श्रेय दिया था , लेकिन इस क्वीन ( printइसके बजाय say) का कोई श्रेय नहीं है ।
ThisSuitIsBlackNot

btw, पिछले कुछ समय के लिए चलने के बाद वास्तव में segfault करता है। धन्यवाद फिर से, @ इल्मरी!
ThisSuitIsBlackNot

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

ठीक है, मैंने मूल अनिर्दिष्ट छोड़ दिया है। भले ही, 3 बाइट्स के लिए धन्यवाद और मूल प्रेरणा के लिए धन्यवाद।
ThisSuitIsBlackNot

5

स्व-संशोधित ब्रेनफ *** (एसएमबीएफ) , 14 बाइट्स

अनुगामी न्यूलाइन \nको शाब्दिक, यूनिक्स, न्यूलाइन (ASCII कोड 10) होना चाहिए।

[<[<]>[.>]<.]\n

स्पष्टीकरण:

कोड पॉइंटर को उसके स्रोत कोड के बाईं ओर ले जाता है, फिर सभी को प्रिंट करता है, जिसमें न्यूलाइन (नियम का दो बार b / c) शामिल है। लूप जारी रहता है।


तुम्हारा मतलब है, यह होना है \r?
इस्माईल मिगुएल

@IsmaelMiguel No. \nएक नई पंक्ति है, और ASCII कोड 10 है, इसलिए स्रोत कोड के हेक्स-डंप में 0Aउस बाइट का मान होगा । code.cside.com/3rdpage/us/newLine.html
mbomb007

1
@IsmaelMiguel सच नहीं है। जब आप कोड टाइप करते हैं, तो आप वास्तव में एक न्यूलाइन के लिए एंटर कुंजी दबाते हैं। \nआम तौर पर आपके कोड में 2 अक्षर और 2 बाइट्स के रूप में गिना जाता है। मैंने इसे पठनीयता के लिए टाइप किया, क्योंकि स्वरूपण मेरे स्रोत कोड के अंत में एक रिक्त रेखा दिखाने के लिए अच्छी तरह से काम नहीं करता है। और इसलिए मुझे यह बताना पड़ा कि यह एक बाइट थी, दो नहीं।
mbomb007

2
\nहमेशा एक एकल वर्ण होता है, जिसे लाइनफीड कहा जाता है । हालाँकि, एक नई पंक्ति बाइट्स का एक प्लेटफ़ॉर्म-निर्भर अनुक्रम है।
डेनिस

2
@ डेनिस हो सकता है, लेकिन मुझे परवाह नहीं है। मैं /"सॉलिडस" नहीं कहता , और मैं किसी को भी नहीं जानता। "न्यूलाइन" एक के साथ शुरू होता है n, और वह बच चरित्र है, इसलिए मैं इसे कहता हूं। "कैरिज रिटर्न" की तुलना में यह "लाइन फीड" के करीब है।
mbomb007

3

पॉवरशेल, 143 बाइट्स

$d='$d={0}{1}{0}{2}while(1){3}Write($d -f [char]39,$d,"`n",[char]123,[char]125){4}'
while(1){Write($d -f [char]39,$d,"`n",[char]123,[char]125)}

रोसेटा कोड पॉवरशेल क्वीन के आधार पर , मुझे पूरा विश्वास है कि यह सबसे कम संभव नहीं है। पावरशेल में स्ट्रिंग रिप्लेसमेंट फॉर्मेटिंग इसके लिए icky है, क्योंकि उसी डिलिमिटर्स को जहां रिप्लेस {}करने के लिए कोड भी ब्लॉक करते हैं while{}, इसलिए हमें [char]कास्टिंग का उपयोग करना होगा , जो कोड को एक गुच्छा बना देता है।


3

अंडरलोड, 25 बाइट्स

पहली बार मैंने ऐसा कुछ करने की कोशिश की है और मुझे यकीन नहीं है कि सभी नियमों का पालन किया जाएगा क्योंकि यह कुछ पंक्तियाँ हैं। न्यूलाइन थोड़ा दर्द भरा था।

(::a~*S:a~*^
)::a~*S:a~*^

1
@ mbomb007 प्रति आउटपुट आउटपुट प्रोग्राम की दो लाइनें हैं। मैंने इसे यहां
मिकी टीटी

3

Befunge , 30 20 बाइट्स

<,+55,*2+98_ #!,#:<"

एक लोकप्रिय befunge quine का एक रूपांतर जो एक नई रेखा को प्रिंट करता है और स्टैक पर -1 को पॉप करता है यदि यह लाइन पूरी करता है।
दुर्भाग्य से, एक पंक्ति में चीजों को करते समय Befunge क्रिया हो जाता है। मैंने लॉन्च किए गए सभी लॉन्चपैड्स ( #) को हटाने की कोशिश की , लेकिन कुछ कमांड (जैसे ,) को छोड़ने के लिए कुछ छोड़ना पड़ा ।

परिवर्तन:

30-20 -> बेस क्वीन को कस्टम में बदल दिया जो मैंने बनाया जो स्ट्रिंग इनपुट का उपयोग करता है। इस तरह, ब्रांचिंग बहुत आसान है।

पुराना:

:0g,:93*`>0-10 #,+$#: #5 _1+>

मुझे नहीं लगता कि यह इष्टतम है, लेकिन यह अभी के लिए स्वीकार्य है।


आप एक स्थान को हथियाने के लिए एक निर्देश प्राप्त कर सकते हैं, और एक बाइट के लिए इसमें 2 जोड़ सकते हैं 98+2/: <, + 55, + 2g1_ #!, #: <"
MildlyMilquetoast

और बोली और न्यूलाइन को पहले धक्का दें और प्रिंटर को उलट दें,-1g0:+5<>:#,_1"
जो किंग


2

आर, 34 बाइट्स

repeat{write(commandArgs()[5],'')}

निम्नानुसार कमांड लाइन से आह्वान करना:

Rscript -e "repeat{write(commandArgs()[5],'')}"

2

> <>, 31 29 बाइट्स

पारंपरिक > <> क्वीन का एक सरल संशोधन ।

"ar00gc0.0+efooooooooooooooo|

चलाने के लिए, इसे यहां पेस्ट करें , 'सबमिट' पर क्लिक करें, फिर 'प्रारंभ' (बिना एनीमेशन के काम करना) काम नहीं करता। निष्पादन की गति बढ़ाने के लिए स्वतंत्र महसूस करें।


"ar00gc0.0+feooooooooooooooo|दो बाइट्स कम है।
कोल

@ धन्यवाद। मैंने दर्पण के बारे में सोचा था, लेकिन एक अलग चुनौती पर नज़र रखने के बाद इसे बदलना भूल गया।
mbomb007


@JoKing पहले से ही एक छोटा> <> समाधान है
mbomb007


2

गोल्फस्क्रिप्ट, 16 बाइट्स

{.".do
":n\p}.do

यह मार्टिन बंटनर की सीजेम प्रविष्टि की तरह लग रहा था । एक दिलचस्प विशेषता यह है कि, जैसा कि यह पता चला है, ".do"जब यह मुद्रित होता है तो ब्लॉक को जोड़ने का सबसे छोटा तरीका यह है कि इसे लाइन टर्मिनेटर को सौंपा जाए n। (निश्चित रूप से, हमें स्ट्रिंग में एक वास्तविक न्यूलाइन शामिल करने की आवश्यकता है, nजिसमें सामान्य रूप से एक को शामिल करना है।) एक ही स्ट्रिंग (गोल्फस्क्रिप्ट में सत्य होना) भी doलूप के लिए स्टैक पर छोड़ दिया जाता है ताकि लूप सुनिश्चित हो सके। हमेशा के लिए चलता है।


1

बीएचएएस, 76 बाइट्स

बस का विरोध नहीं कर सकता, विशेष रूप से यहाँ PowerShell के साथ :)

while true;do
a ()
{
    echo while true\;do
    declare -f a
    echo a\;done
}
a;done

एक कॉपी के लिए व्हाट्सएप महत्वपूर्ण है।


1

जावास्क्रिप्ट (ईएस 6), 64

for(;;(_=>console.log(`for(;;(_=>${arguments.callee})());`))());

वैकल्पिक रूप से (64 भी)

a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a)

वैकल्पिक एक ढेर अतिप्रवाह का कारण नहीं होगा?
पैट्रिक रॉबर्ट्स

नहीं, कोई पुनरावृत्ति नहीं है, इसलिए स्टैक पर कुछ भी नहीं जोड़ना चाहिए।
डंकेमेसेस

ठीक है, ठीक है, मैंने अभी उन दोनों का परीक्षण किया है, आप वैकल्पिक समाधान के बारे में सही हैं, लेकिन आपका पहला समाधान विफल हो गया है और मुझे पता चला है कि क्यों। तीर के कार्यों पर एमडीएन प्रलेखन के अनुसार , "तीर फ़ंक्शन उनके कोड के लिए एक तर्क वस्तु को उजागर नहीं करते हैं" इसलिए आपका arguments.calleeअस्तित्व नहीं है और एक त्रुटि फेंकता है।
पैट्रिक रॉबर्ट्स

दिलचस्प। मेरे लिए फ़ायरफ़ॉक्स डेवलपर संस्करण 42.0a2 (2015-09-13) में दोनों काम करते हैं। मुझे लगता है कि एक बार मानक पूरी तरह से अपना लिए जाने के बाद पहला काम करना बंद हो जाएगा।
डंकेमेसेस

मैंने नवीनतम क्रोम पर उनका परीक्षण किया, क्योंकि मैं !कोष्ठक को घेरने के बजाय आपके पहले समाधान को गोल करने की कोशिश कर रहा था और लूप अर्धविराम शरीर की आवश्यकता से बचने के लिए लूप के लिए फ़ंक्शन निष्पादन को लगा रहा था, जो 4 बाइट्स को बचाएगा (मुझे लगता है)
पैट्रिक रॉबर्ट्स

1

माइक्रोस्क्रिप्ट , 22 बाइट्स

"f1{CqxCanx"f1{CqxCanx

Esolangs लेख से क्वीन के आधार पर "fCqxah"fCqxah:। इस तथ्य को उजागर करता है कि भाषा ऑटोप्शंस को आवश्यकतानुसार बंद कर देती है, जिसके बिना यह दो बाइट्स लंबा होगा।


1

बैच, 10 (फ़ाइल नाम लंबाई के लिए + 4)

सुनिश्चित नहीं हैं कि यह दो कारणों से योग्य है:

  • तकनीकी रूप से, विंडोज कमांड शेल से टेक्स्ट के साइड इफेक्ट्स हो सकते हैं या नहीं, क्योंकि यह इस बात पर निर्भर करता है कि यह कैसे कॉन्फ़िगर किया गया है।
  • यह कार्यक्रम खुद को नाम से पुकारता है, और मुझे यकीन नहीं है कि यह नियमों द्वारा निषिद्ध है (विशेष रूप से "प्रोग्राम फ़ाइल का कोई उद्घाटन नहीं" नियम)। यह पाठ को पढ़ने और छापने के उद्देश्यों के लिए खुद को नहीं खोल रहा है; यह केवल स्वयं को फिर से चला रहा है। इसके अलावा, फ़ाइल सिस्टम संरचना पुराने स्कूल के बैच स्क्रिप्ट का एक अभिन्न अंग है (अक्सर प्रोग्राम राज्य, आदि को स्टोर करने के लिए उपयोग किया जा रहा है)। जैसे, मुझे यकीन नहीं है कि यह 5 वें नियम का उल्लंघन करता है या नहीं।

कोड (q.bat नामक प्रोग्राम के लिए):

echo on&&q

2
मुझे लगता है कि मैं इसकी अनुमति दूंगा क्योंकि यह कम से कम नहीं है, और यह रचनात्मक और अद्वितीय है। और यह स्रोत कोड नहीं पढ़ रहा था, बल्कि खुद को क्रियान्वित कर रहा था।
mbomb007

1
चूंकि फ़ाइल नाम मनमाना नहीं है, इसलिए बहुत कम से कम आपको फ़ाइल का नाम बाइट काउंट में जोड़ना चाहिए।
मार्टिन एंडर

1
मेरा मानना ​​है कि आप इसका उपयोग कर सकते हैं, echo on&&%0हालांकि मैं इसे आज़माने से डरता हूं।
DankMemes

1
अद्यतन: echo on&&%0काम नहीं करता है। %0आउटपुट में विस्तारित के रूप में प्रदर्शित किया जाता है, और विंडोज़ (7, 32 बिट, एक वीएम में चल रहा है) पूरी चीज को बहुत जल्दी समाप्त कर देता है।
DankMemes

1
मुझे लगता है कि आप .batभाग को छोड़ सकते हैं
SuperJedi224

1

सीलोन , 210 208 बाइट्स

बेशक यह कुछ भी नहीं जीतेगा ...

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

मूल:

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

मैंने दो दिन पहलेwhile(true){...} लूप जोड़कर अपनी क्वीन को संशोधित किया है , इसलिए मैं सादे क्वीन के 185 बाइट्स से 210 तक आता हूं (मुझे अब नई लाइन चरित्र की आवश्यकता नहीं है)। लेकिन तब मैंने पाया कि एक while(1<2){...}लूप दो बाइट्स से भी छोटा होता है:

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

(सीलोन का for(;;)जावा की तरह कोई लूप नहीं है , और इस लूप के लिए ब्रेस की भी आवश्यकता होती है।)


1

पॉवरशेल, 132 107 बाइट्स

$a='$a={0}{1}{0};for(){2}$a-f[char]39,$a,[char]123,[char]125{3}';for(){$a-f[char]39,$a,[char]123,[char]125}

रोसेटा क्वीन के आधार पर (@AdmBorkBork के रूप में भी) स्ट्रिंग प्रतिस्थापन के लिए प्रारूपण का उपयोग नहीं करता है ... शायद एक पाश के लिए स्विचन और स्वरूपण का उपयोग करना सबसे अच्छा होगा?

मुझे यकीन है कि अगर AdmBorkBork वापस आया तो वे इसे बहुत हरा देंगे: P

संपादित करें लूप और प्रतिस्थापन के लिए, मेरे पूर्ववर्ती के लिए सभी धन्यवाद :)

पुराना प्रयास:

$a='$a=;for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}';for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}


1

जावा 10, 194 बाइट्स

interface M{static void main(String[]a){for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";;)System.out.println(s.format(s,34,s));}}

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं (60 सेकंड के बाद का समय)।

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";
                                //   Unformatted source code
        ;)                      //   Loop indefinitely
       System.out.println(      //    Print with trailing new-line:
         s.format(s,34,s));}}   //     The formatted source code

:

  • स्ट्रिंग sमें बिना स्रोत वाला स्रोत कोड होता है।
  • %sइस स्ट्रिंग को स्वयं के साथ इनपुट करने के लिए उपयोग किया जाता है s.format(...)
  • %c, %1$cऔर 34डबल-कोट्स को फॉर्मेट करने के लिए उपयोग किया जाता है।
  • s.format(s,34,s) यह सब एक साथ रखता है

चुनौती हिस्सा:

  • for(;;) का उपयोग अनिश्चित काल के लिए किया जाता है।
  • System.out.println(...) का उपयोग नई लाइन के पीछे प्रिंट करने के लिए किया जाता है





1

ब्रेकीलॉग , 16 बाइट्स

∋"∋~kgjẉ₁⊥"gjẉ₁⊥

आप इसे ऑनलाइन करने का प्रयास नहीं कर सकते , लेकिन मैंने सत्यापित किया है कि यह मेरी स्थापना पर काम करता है।

ब्रेकीलॉग , 18 बाइट्स

∋"∋~kgjw₁⊥~n"gjw₁⊥

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

इस क्वीन के वैकल्पिक संस्करण से अनुकूलित , एक बैकग्राउंड हैक के साथ मैंने शुरू में सभी चीजों के बोगोसॉर्ट के लिए तैयार किया था । दो बाइट्स पर खर्च करता है ~nक्योंकि (एक अनुगामी न्यूलाइन के साथ मुद्रण के लिए सामान्य साधन) टीआईओ पर चरित्र एन्कोडिंग के साथ कुछ अजीब मुद्दों को हिट करता है, और स्ट्रिंग शाब्दिक में डाला गया एक वास्तविक न्यूलाइन के ~kरूप में के माध्यम से मुद्रित हो जाता है \n

               w      Print
 "∋~kgjw₁⊥~n"         "∋~kgjw₁⊥~n"
∋                     which is an element of
                      the (unused and unconstrained) input
                ₁     formatted
          ~n          (so that the ~n is replaced with a newline)
             gj       with itself
   ~k                 (so that the ~k is replaced with the string in quotes),
                 ⊥    then try again.

चूंकि w₁एक सूची के रूप में इनपुट लेता है [string to be formatted, formatting arguments], एक सूची में एक स्ट्रिंग को लपेटने के साथ gफिर इसे स्वयं के साथ समेटना और इसे स्वयं के साथ jस्वरूपित करने की अनुमति देता है। और चूंकि प्रोग्राम को कोई इनपुट नहीं दिया गया है, इसलिए इनपुट वेरिएबल जो कि प्रोग्राम की शुरुआत में मौजूद है, किसी भी मूल्य पर ले जा सकता है, इसलिए यह एक असीम रूप से कई सूचियों में से एक के लिए विवश हो सकता है, जिसमें "∋~kgjw₁⊥~n"एक तत्व होता है, एक सिंगल क्रिएट करना पसंद की बात यह है कि इसके स्रोत को प्रिंट करने के बाद प्रोग्राम हिट हो जाए



हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.