धीमी गति से बढ़ रहा है

Question

एक क्विन बनाओ।

आसान लगता है? अच्छी तरह से इस क्वीन का आउटपुट पहले प्लस के साथ होना चाहिए, जो इसके बाद अपने दूसरे कैरेक्टर के साथ-साथ इसके दूसरे कैरेक्टर को भी आउटपुट करता है।

इस तरह से क्वीन को कई पीढ़ियों में दो प्रतियों का उत्पादन करना चाहिए।

उदाहरण: अपना कोड होने दें x। इसे चलाना आउटपुट चाहिए x + x[:1]। परिणामी कार्यक्रम को चलाने के लिए आउटपुट x + x[:2]और इतने पर होना चाहिए ...

यदि आपका कोड था foobar, तो इसे चलाना चाहिए foobarf। इसे चलाना आउटपुट चाहिए foobarfo। और इसी तरह से आगे और इस पैटर्न का अनुसरण करें:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

आपका प्रोग्राम 2 बाइट्स से अधिक लंबा होना चाहिए और प्रत्येक पुनरावृत्ति के अपने कोड का केवल एक अतिरिक्त वर्ण आउटपुट करना चाहिए।

Comments

मुझे संदेह है कि अधिकांश भाषाओं में यह चुनौती असंभव है, यह देखते हुए कि डिफ़ॉल्ट रूप से स्रोत कोड पढ़ना निषिद्ध है।

— अर्जन जोहान्सन

@ अर्जन जोहानसेन और उसके बाद डेनिस ने दिखाया

— रॉड

@ अच्छी तरह से मैंने यह सब नहीं कहा , यह सिर्फ इतना है कि कई / अधिकांश भाषाओं में कोड के मनमाने टुकड़े जोड़ने का कोई स्पष्ट तरीका नहीं है, इस तरह से (1) यह एक वाक्यविन्यास त्रुटि नहीं देता है (2) कार्यक्रम परिवर्तन का पता लगा सकता है।

— अर्जन जोहान्सन

चूंकि यह एक बहुत ही असामान्य क्वीन है, क्या सामान्य क्वाइल लूपहोल्स अभी भी अस्वीकृत हैं?

— ड्रेकोनिस

Answer 1

Zsh ,110 108 100 बाइट्स

a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

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

तो यह संभव है।

व्याख्या

a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

Comments

संबंधित: codegolf.stackexchange.com/q/100930/25180

— jimmy23013

Answer 2

आर, 289 बाइट्स

s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

प्रेरणा के लिए इस रानी को श्रेय । केवल तभी काम करता है जब पिछली आर के समान आर वातावरण में चलाया जाता है।

Comments

एक स्पष्टीकरण आगामी होगा ... मैंने अभी तक 288 बार इसका परीक्षण नहीं किया है, लेकिन मैं काफी आश्वस्त हूं कि यह सही है

— Giuseppe

यह निश्चित रूप से 289 बाइट्स होना चाहिए, क्योंकि रानी एक नया चरित्र जोड़ती है, लेकिन वैसे भी इसके महान आप इसे हल कर चुके हैं!

— IQuick 143

आह, आप सही कह रहे हैं, catनई कड़ियाँ जोड़कर बेवकूफ ।

— ग्यूसेप

लेकिन क्या यह पूरा कार्यक्रम है? क्या उत्पन्न कोड पूर्ण कार्यक्रम हैं?

— jimmy23013

@ jimmy23013 जहां तक ​​मैं बता सकता हूं, यह उत्तर और उत्पन्न कोड पूर्ण कार्यक्रम हैं। कोई है mainया कि आर में की तरह किसी भी अन्य अनिवार्य संरचना इसके अलावा, सवाल स्पष्ट रूप से एक पूरा कार्यक्रम के लिए पूछना नहीं है, एक समारोह तो या इसी तरह करना होगा।

— स्टेडीबॉक्स

Answer 3

एलिस , 29 बाइट्स

4P.a+80pa2*&wdt,kd&w74*,.ok@

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

अप्राप्य वर्ण 0x18 है।

व्याख्या

सामान्य- "आधारित फ़ंजोइड क्वाइन के साथ परेशानी यह है कि यदि हम पूरे स्रोत कोड को दोहराते हैं, तो हम अतिरिक्त भी प्राप्त करते हैं "और स्ट्रिंग अब पूरे स्रोत कोड को कवर नहीं करती है। मुझे लगता है कि gइसके बजाय मौजूदा जवाब धोखा-वाई दृष्टिकोण का उपयोग करता है ।

यह उत्तर- "आधारित दृष्टिकोण का उपयोग करता है , लेकिन "स्रोत में शामिल करने के बजाय , हम इसे रनटाइम में प्रोग्राम में लिखते हैं। इस तरह, "कार्यक्रम की पुनरावृत्ति कितनी बार होगी, इसकी परवाह किए बिना केवल एक ही होगा (क्योंकि हम इसे केवल एक विशिष्ट समन्वय के लिए लिखते हैं, स्वतंत्र रूप से कार्यक्रम के आकार का)।

सामान्य विचार यह है कि हम स्टैक पर पूरे स्रोत कोड का प्रतिनिधित्व करते हैं, लेकिन केवल कोड के आकार द्वारा निर्धारित लूप की लंबाई के साथ वर्णों के पहले 29 (यानी प्रोग्राम की लंबाई) के माध्यम से चक्र। इसलिए, हम वास्तव में (वर्णों को छोड़कर) के माध्यम से मनमाने चरित्रों को जोड़ सकते हैं @और परिणाम हमेशा कोर प्रोग्राम का एक चक्रीय दोहराव होगा, स्रोत से एक वर्ण अधिक लंबा।

4P   Push 4! = 24. This is the code point of the unprintable, which we're 
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all 
     characters after it (including those from extraneous repetitions). Then 
     on top we have the characters that come in front of the `"`. 
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Comments

महान समाधान। मुझे स्पष्टीकरण पसंद है।

— 14:11 बजे 143

Answer 4

पर्ल 5 , 83 बाइट्स (अंतिम न्यूलाइन सहित)

$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

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

अच्छा ol ' __DATA__टोकन किसी भी पर्ल प्रोग्राम में एक मनमाना स्ट्रिंग को जोड़ना आसान बनाता है, जिसे मुख्य प्रोग्राम तब <DATA>फ़ाइल हैंडल के माध्यम से एक्सेस कर सकता है (और वास्तव में उपयोग कर रहा है __END__, जो __DATA__दो अतिरिक्त बाइट्स को बचाने के बजाय पीछे की संगतता के लिए एक ही काम करता है ) ।

ध्यान दें कि यह कार्यक्रम अपने स्वयं के स्रोत कोड को नहीं पढ़ता है, लेकिन __END__टोकन के बाद केवल अतिरिक्त इनपुट डेटा अपने स्रोत से जुड़ा हुआ है । वास्तव में, __END__टोकन और उसके बाद सब कुछ इस तरह का कार्य करता है जैसे इनपुट के अंत तक स्ट्रिंग स्ट्रिंग शाब्दिक।

यह भी ध्यान दें कि वास्तव में कल्पना को पूरा करने के लिए, यह कार्यक्रम एक नई सीमा में समाप्त होना चाहिए। यदि ऐसा नहीं होता है, तो नई लाइन वास्तव में स्वचालित रूप से दूसरे के बाद __END__वैसे भी संलग्न हो जाती है, लेकिन फिर पहला पुनरावृत्ति आउटपुट कोड के बराबर नहीं होगा और इसके पहले बाइट किसी भी अधिक होगा।

Answer 5

Befunge-98 , 30 बाइट्स

0>:#;0g:840#;+*#1-#,_$a3*%0g,@

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

मेरी कोशिश है कि Befunge-98 का ​​उपयोग करके एक स्पेस टर्मिनेटेड quine का उपयोग किया जाए जो यह भी गिनाता है कि कितने वर्ण आउटपुट किए गए हैं। हालाँकि gकमांड का उपयोग करता है ।

Comments

आप पहली पंक्ति में उल्लेख कर सकते हैं कि यह गैर-प्रतिस्पर्धात्मक / धोखा है, बस किसी भी पतन को हतोत्साहित करने के लिए इसे अन्यथा प्राप्त कर सकते हैं।

— क्विंटोपिया

Answer 6

PHP, 146 बाइट्स

ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

इसे -rकमांड लाइन में उपयोग करके चलाया जाना चाहिए ।

Comments

जब मैं इसे ऑनलाइन आज़माता हूँ तो यह काम नहीं करता है ! , यह सिर्फ एक साधारण रानी है।

— अर्जन जोहानसन

@ WithrjanJohansen आपको इसे चलाना चाहिए php -r 'command'।

— jimmy23013

गह, यह काम करने के लिए नहीं मिल सकता है। TIO सिर्फ -r तर्कों की अनदेखी करता है।

— अर्जन जोहानसन

@ ShouldrjanJohansen यह है कि आपको इसका परीक्षण कैसे करना चाहिए।

— jimmy23013

अहा। मुझे तब कुछ गलत समझ लेना चाहिए था। अब मैं इसे भाषा सेटिंग के रूप में PHP के साथ काम करने में कामयाब रहा ।

— अर्जन जोहान्सन

Answer 7

रूनिक एनचेंमेंट्स , 61 बाइट्स

803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

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

ऐलिस जवाब के समान दृष्टिकोण का उपयोग करता है: प्रतिबिंबित रूप से स्ट्रिंग "कमांड को कोड में लिखता है ताकि केवल एक ही हो। बाकी मूल कार्यक्रम को पुनर्प्राप्त करने के लिए बहुत सारे स्ट्रिंग और स्टैक हेरफेर हैं, कितने अतिरिक्त बाइट्स की आवश्यकता है, और आवश्यक हॉक प्रिंट करें।

}͍अनुक्रम में स्मृति स्ट्रिंग प्रतिनिधित्व घूमता है तो चारों ओर है कि 803X4+kwमें प्रकट होता है बजाय अंत में की शुरुआत, की स्थिति की वजह से" है और वहाँ अजीब संख्या का एक बहुत की गणना करने के बिना इस आपरेशन से निपटने में एक आसान तरीका नहीं है ।

जबकि मूल कार्यक्रम 61 बाइट्स है इसकी स्ट्रिंग-लंबाई केवल 50 है, जो कि निर्माण करना आसान है 5Xऔर यह केवल संयोग था कि सभी आवश्यक कार्यक्षमता वाले (उदाहरण के लिए लंबाई 49 कार्यक्रम आसान होगा) के बाद इसे गद्देदार करने की आवश्यकता नहीं थी 50एक शाब्दिक सांकेतिक शब्दों में बदलना करने के बजाय पैडिंग के एक बाइट के साथ सांकेतिक शब्दों में बदलना 49, जबकि 53 के 51रूप में इनकोड किया जाएगा 5X3+, अपने स्वयं के अतिरिक्त बाइट्स के लिए खाते में)।