64

एक प्रोग्राम लिखें जो आउटपुट देता है

Do not repeat yourself!

आपके प्रोग्राम कोड को निम्नलिखित बाधाओं का सम्मान करना चाहिए:

इसकी लंबाई एक सम संख्या होनी चाहिए
प्रत्येक वर्ण जो स्थिति में है 2n(जहां nपूर्णांक है 0) स्थिति में वर्ण के बराबर होना चाहिए 2n-1। कार्यक्रम का दूसरा वर्ण पहले के बराबर है, चौथा तीसरे के बराबर है, आदि।

चरित्रों के रूप में गिनती की नई कहानी!

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

उदाहरण

HHeellllooWWoorrlldd एक वैध कार्यक्रम है

123या AAABBBया HHeelloसही नहीं हैं

सत्यापन

इस CJam स्क्रिप्ट का उपयोग आप यह सत्यापित करने के लिए कर सकते हैं कि आपका स्रोत कोड मान्य है। बस अपने कोड को "इनपुट" बॉक्स में पेस्ट करें और स्क्रिप्ट चलाएं।

code-golf kolmogorov-complexity restricted-source

— अरनॉड
स्रोत

51

मजेदार तथ्य: अगर समस्या के बजाय DDDooo nnnooottt rrreeepppeeeaaattt yyyooouuurrrssseeelllfff!!!

— ट्रिपल्स थे

14

मुझे लगा कि यह बहुत अधिक प्रतिबंधात्मक हो सकता है, लेकिन जवाबों की हड़बड़ाहट मुझे गलत साबित करती है। अच्छा प्रश्न!

— ट्राइकोप्लाक्स

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

— डेफ़र

1

क्या कोई स्कोरिंग स्निपेट जोड़ सकता है? मुझे वे पसंद हैं, और मैं चाहता हूं कि हर सवाल उनके पास हो।

— mbomb007

सभी मौजूदा जवाब गूढ़ हैं। मुझे आश्चर्य है कि क्या यह सामान्य लैंग में संभव है?

— डंकेमेसेस

51

हेक्सागोनी , 166 126 124 बाइट्स

\\;;;;33rr''22DD..));;;;;;oo;;}}eeoo\\@@nn;;;;ee;;;;aass&&;;uuoo;;;;..\\\\;;ttee..pp;;tt;;;;..rr;;''ll..'';;;;..;;}}ff..}}yy

निहित नो-ऑप और व्हाट्सएप को सम्मिलित करते हुए, यह निम्नलिखित स्रोत कोड से मेल खाता है:

       \ \ ; ; ; ; 3
      3 r r ' ' 2 2 D
     D . . ) ) ; ; ; ;
    ; ; o o ; ; } } e e
   o o \ \ @ @ n n ; ; ;
  ; e e ; ; ; ; a a s s &
 & ; ; u u o o ; ; ; ; . .
  \ \ \ \ ; ; t t e e . .
   p p ; ; t t ; ; ; ; .
    . r r ; ; ' ' l l .
     . ' ' ; ; ; ; . .
      ; ; } } f f . .
       } } y y . . .

मुझे यकीन है कि इसे और भी छोटा करना संभव है, और शायद इसे साइड-लेंथ 6 में भी हल किया जाए, लेकिन यह मुश्किल हो रहा है ...

यह काम किस प्रकार करता है

^{टिमग्राम के हेक्सागोनी कलरर के साथ उत्पन्न आरेख ।}

कोड पूरी तरह से रैखिक है। \शुरू में सही आड़ा, ऐसा है कि हम सब पर दोगुनी पात्रों के बारे में चिंता करने की जरूरत नहीं है में आईपी पुनर्निर्देश। रंगीन रास्तों को नारंगी / लाल, नीला / ग्रे, हरा, बैंगनी रंग में निष्पादित किया जाता है (जब एक ही रंग के दो मार्ग होते हैं, तो बाएं हाथ के पथ को पहले निष्पादित किया जाता है, दाएं हाथ के चारों ओर लपेटने से पहले)।

यदि हम नो-ऑप्स, दर्पणों और आदेशों को अनदेखा करते हैं जो दूसरों द्वारा ओवरराइड किए जाते हैं, तो रैखिक कोड इस पर नीचे आता है:

D;o;&32;}n;o;t;';}r;e;p;e;a;t;';}y;o;u;r;s;e;l;f;');@

हेक्सागोनी में पत्रों ने वर्तमान मेमोरी एज के मूल्य को पत्र के चरित्र कोड में सेट किया। ;वर्तमान मेमोरी एज को एक पात्र के रूप में प्रिंट करता है। हम &मेमोरी किनारे को रीसेट करने 0और इसके साथ एक स्पेस प्रिंट करने के लिए उपयोग करते हैं 32;। }एक अलग किनारे पर जाता है, ताकि हम 32आगे के रिक्त स्थान के लिए याद कर सकें । बाकी कोड केवल नए किनारे पर अक्षरों को प्रिंट करता है, और कभी-कभी ';}किसी स्थान को प्रिंट करने के लिए आगे और पीछे चलता है। अंत में हम फिर से अंतरिक्ष के किनारे पर जाते हैं ', मूल्य को 33 के साथ बढ़ाते हैं )और विस्मयादिबोधक चिह्न प्रिंट करते हैं। @कार्यक्रम को समाप्त करता है।

— मार्टिन एंडर
स्रोत

4

यह वास्तव में प्रभावशाली है !!!

— जादूगरऑफमेनो सेप

आप इस निष्कर्ष पर कैसे पहुंचे कि यह आकार 6 या 5 में भी संभव है ? मैं आकार 7 को केवल मुश्किल से फिटिंग के रूप में देखता हूं।

— तिमवी

@ टिमिवी 5 शायद थोड़ा अधिक था, लेकिन एकल के अपवाद के साथ ;, कोड में चरित्र जोड़े के बीच अभी तक कोई पुन: उपयोग नहीं हुआ है। वर्तमान कोड बहुत ज्यादा पहली बात है जो मेरे दिमाग में आई है, इसलिए मैं सोच रहा हूं कि अगर कोई बहुत कठिन प्रयास करता है, तो इसे और अधिक जटिल समाधान ढूंढना संभव है जो अर्धविराम और शायद कुछ अक्षरों का पुन: उपयोग करता है, इसे फिट करने के लिए साइड में लंबाई 6.

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

आकार 6 पाने के लिए, आपको आकार 7. की तुलना में 36 वर्णों को सहेजना होगा। भले ही आपके पास वर्तमान में आपके द्वारा उपयोग किए गए 6 अप्रयुक्त स्लॉट का उपयोग किया गया हो, फिर भी आपको 30 को सहेजना होगा। आप ;केवल एक बार पुनः उपयोग कर सकते हैं क्योंकि आप उन्हें क्षैतिज रूप से पार नहीं कर सकता। ;आपके कोड में केवल 23 s हैं, और केवल 6 वर्ण दोहराव (2 × o, 1 × t, 1 × r, 2 × e), केवल 29 दे रहे हैं। व्यक्तिगत रूप से, मुझे इससे अधिक विश्वास दिलाता हूं कि आकार 6 असंभव है। ।

— टिम्पी

44

गोल्फस्क्रिप्ट, 130 84 76 बाइट्स

22..!!..00)){{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}``%%>><<[[33]]++

इसे ऑनलाइन वेब गोल्फस्क्रिप्ट में आज़माएं ।

यह काम किस प्रकार करता है

गोल्फस्क्रिप्ट दुभाषिया स्टैक पर एक खाली स्ट्रिंग रखकर शुरू होता है।

22 # Push 22.
.. # Push two copies.
!! # Negate the last copy twice. Pushes 1.
.. # Push two copies.
00 # Push 0.
)) # Increment twice. Pushes 2.

   # STACK: "" 22 22 1 1 1 2

{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}

`` # Push a string representation of the string representation of the block.

   # This pushes "{{DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff}}" (with quotes).

%% # Take every second element of that string, then every element of the result.
>> # Discard the first element of the result. Repeat.
<< # Truncate the result to length 22. Repeat.
[[ # Begin a two-dimensional array.
33 # Push 33, the character code of '!'.
]] # End the two-dimensional array.
++ # Concatenate the empty string, the 22-character string and the array [[33]].

एक स्ट्रिंग के साथ एक सरणी समतल करना, इसलिए परिणाम वांछित आउटपुट है।

— डेनिस
स्रोत

38

यूनरी , ~ 1.86 × 10 ²²²

सरल मस्तिष्क -> एकात्मक उत्तर। बहुत उप-इष्टतम;)

कार्यक्रम में 0 की सम संख्या होती है; विशेष रूप से:

1859184544332157890058930014286871430407663071311497107104094967305277041316183368068453689248902193437218996388375178680482526116349347828767066983174362041491257725282304432256118059236484741485455046352611468332836658716

उनमें से।

मूल मंथन कोड:

++++[++++>---<]>+.[--->+<]>+++.[--->+<]>-----.+[----->+<]>+.+.+++++.[---->+<]>+++.---[----->++<]>.-------------.+++++++++++.-----------.----.--[--->+<]>-.[---->+<]>+++.--[->++++<]>+.----------.++++++.---.+.++++[->+++<]>.+++++++.------.[--->+<]>-.

— Maltysen
स्रोत

3

आपके द्वारा प्रदान किए गए कोड ब्लॉक में से कोई भी डबल-अप नियम को संतुष्ट नहीं करता है। मैं क्या खो रहा हूँ?

— doppelgreener

26

@doppelgreener: "कोड" का पहला ब्लॉक केवल एक बड़ी संख्या है। विशेष रूप से, 1Unary प्रोग्राम में s की संख्या जो अनुरोधित स्ट्रिंग को आउटपुट करती है। दूसरा कोड ब्लॉक BF प्रोग्राम है जो इसका उत्पादन करने के लिए उपयोग किया गया था। जैसा कि यूनरी कार्यक्रम पूरी तरह से 1एस से बना है , यह पुनरावृत्ति आवश्यकता को तुच्छ रूप से संतुष्ट करता है।

— एलेंडिया स्टट्रान

8

इसके अलावा शून्य की संख्या (सौभाग्य से?) एक सम संख्या है :-)

— अरनौद

1

मैंने उत्तर को संपादित करने के लिए स्वतंत्रता ले ली है ताकि नंबर ऐसा न लगे कि यह कोड माना जाता है।

— तिमवी सिप

2

@Kametrixom यह यूनरी कार्यक्रम का एक गोलुनार वर्णन है। लिखित रूप में गोलुनार कार्यक्रम शर्तों को पूरा नहीं करता है।

— पाओलो एबरमन

34

रूबी - 2100 1428 1032 820 670 बाइट्स

यह मानता है कि आउटपुट एक फ़ंक्शन से रिटर्न वैल्यू हो सकता है (यह निर्दिष्ट नहीं किया गया था कि आउटपुट को STDOUT में होना चाहिए)

कोड:

((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

चाल को ""परिशिष्ट संचालन <<और वर्णों के ASCII कोडों का उपयोग करके एक स्ट्रिंग से स्ट्रिंग का निर्माण करना है ।

एएससीआईआई कोड के लिए नंबर प्राप्त करने के लिए मैं संख्या को उन मूल्यों में विघटित करने की कोशिश कर रहा हूं जिन्हें मैं आसानी से उत्पन्न कर सकता हूं। उदाहरण के लिए ASCII 90बस है 88+1+1, जो है:

88 यह अपने आप ठीक है
11**00है 11^0, जो बस है1

सौभाग्य से दोनों ++और --मतलब होगा addमाणिक में, तो मैं लिख सकते हैं 90के रूप में88++11**00++11**00

केवल 1s जोड़ने की तुलना में कुछ नंबरों को प्राप्त करने के लिए कुछ तरकीबें हैं, यहाँ ऊपर उत्पन्न करने के लिए कोड का उपयोग किया जा रहा है (जिसमें मेरे द्वारा उपयोग किए जा रहे सभी मैपिंग शामिल हैं):

d = "Do not repeat yourself!"

d.each_char do |c|
  print "(("
end

print '""'

VALUES = [
  [0,'00'],
  [1,'11**00'],
  [4,'((11**00<<11**00<<11**00))'],
  [5,'((11>>11**00))'],
  [11,'11'],
  [16,'((33>>11**00))'],
  [22,'22'],
  [27,'((55>>11**00))'],
  [33,'33'],
  [38,'((77>>11**00))'],
  [44,'44'],
  [49,'((99>>11**00))'],
  [55,'55'],
  [66,'66'],
  [77,'77'],
  [88,'88'],
  [99,'99']
].reverse

d.each_char do |c|
  print "<<"
  num = c.ord
  while num != 0
    convert = VALUES.find{|val|val.first<=num}
    print convert.last
    num -= convert.first
    print "++" unless num == 0
  end
  print "))"
end

मैं अभी भी अन्य चाल के बारे में सोच रहा हूं कि किसी संख्या को पाने के लिए आवश्यक वर्णों को कम करना है।

ध्यान दें कि यदि आप -rppध्वज का उपयोग करते हैं , और ppकोड को इस तरह शुरू करें:

pp((((((((((((((((((((((((((((((((((((((((((((((""<<66++11**00++11**00))<<99++11++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11))<<99++11++11**00))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++11++((11**00<<11**00<<11**00))))<<99++11**00++11**00))<<99++11++11**00++11**00))<<99++11**00++11**00))<<88++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++((33>>11**00))++11**00))<<((55>>11**00))++((11>>11**00))))<<99++22))<<99++11++11**00))<<99++((33>>11**00))++11**00++11**00))<<99++11++((11**00<<11**00<<11**00))))<<99++((33>>11**00))))<<99++11**00++11**00))<<99++((11>>11**00))++((11**00<<11**00<<11**00))))<<99++11**00++11**00++11**00))<<33))

फिर अतिरिक्त 2 + 4 बाइट्स के लिए यह पूरी तरह से पूर्ण कार्यक्रम के रूप में कार्य कर सकता है, लेकिन यह "आवश्यक स्ट्रिंग से पहले और बाद में एक अतिरिक्त प्रिंट करेगा :

उदाहरण:

$ ruby -rpp golf.rb
"Do not repeat yourself!"

— SztupY
स्रोत

क्या आप स्पष्ट कर सकते हैं कि यह पूरी तरह से अनुपालन क्यों नहीं है? यह मेरे लिए एकदम सही है, और यहां तक कि ppमणि एक डबल अक्षर है ...

— ट्राइकोप्लाक्स

3

@trichoplax: यह पोस्ट में है: 1. "आउटपुट में अतिरिक्त अक्षर और 2. -rppध्वज की आवश्यकता (जो पसंद नहीं है --rrpp)

— SztupY

1

यह उत्तर शांत है लेकिन विशिष्टताओं को पूरा नहीं करने वाले उत्तर विलोपन के अधीन हैं।

— गेहूं जादूगर

1

@ नियम पूर्ण रूप से स्पष्ट होने के लिए, यह उन प्रतिक्रियाओं को हटाने के लिए साइट नीति है जो चुनौती के नियमों का पालन नहीं करते हैं।

— माइक बुफर्देसी

1

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

— माइक बुफर्देसी

23

> <> , 174 बाइट्स

vv

77

99

**

00

77

bb

**

pp

""

!!

ff

ll

ee

ss

rr

uu

oo

yy



tt

aa

ee

pp

ee

rr



tt

oo

nn



oo

DD

""

~~

oo

ll

11

==

;;

00

66

bb

**

..

शुक्र है, एक मायने में प्रतिबंध लंबवत रूप से लागू नहीं होता है। हालांकि, सबसे बड़ी समस्या यह है कि हमें हर नईलाइन को दोगुना करने की आवश्यकता है।

मोटे तौर पर चलने वाला कोड इस प्रकार है:

v            Redirect instruction pointer to move downwards
79*07b*p     Place a ? on row 77 before the first ;
"..."        Push "Do not repeat yourself!" backwards, riffled between spaces

[main loop]
~o           Pop a space and output a char
l1=?;        If there is only the final space left, halt
06b*.        Jump back to the start of the loop

ध्यान दें कि प्रोग्राम में कोई दोहरा स्थान नहीं है - जब स्ट्रिंग मोड में,> <> रिक्त कोशिकाओं के लिए रिक्त स्थान को धक्का देता है। इसके विपरीत, इसका मतलब है कि इसका उपयोग करने वाला एक समाधान g(स्रोत कोड से एकल कक्ष पढ़ें) मुश्किल हो जाएगा, क्योंकि कार्यक्रम में जो रिक्त स्थान हैं वे पढ़ने के दौरान एनयूएल बन जाते हैं।

^{(नोट: यदि यह एक त्रुटि के साथ समाप्त होता है, तो यह 50 बाइट्स छोटा हो सकता है , लेकिन मुझे यह इस तरह से पसंद है।)}

— Sp3000
स्रोत

1

नौकरी के लिए सही उपकरण ...

— आउटगॉल्फ

20

स्किलिंग , 186 146 बाइट्स

끄끄 닶닶 긂긂 닦닦 닶닶 덇덇 긂긂 댧댧 뉖뉖 댇댇 뉖뉖 눖눖 덇덇 긂긂 뎗뎗 닶닶 덗덗 댧댧 댷댷 뉖뉖 닆닆 뉦뉦 긒긒

껢껢 鎵鎵 ❶❶ 合合虛虛替替標標現現併併一一終終

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

व्याख्या

शुरुआत में कोरियाई पात्रों का ब्लॉक स्ट्रिंग को धक्का देता है "DDDof� \"\u0002nf�of�twG \"\u0002rw'efVpw\aefVaf\u0016twG \"\u0002yw�of�uwWrw'sw7efVlf�fff!\"\u0012"। आप देखेंगे कि हर तीसरा चरित्र एक ऐसा चरित्र है जिसे हम चाहते हैं; बाकी जिबरिश है। यहाँ पर क्यों:

स्किलिंग में, दो कोरियाई वर्ण तीन बाइट्स को एन्कोड करते हैं। इस प्रकार, प्रत्येक कोरियाई चरित्र प्रभावी रूप से 12 बिट्स को एन्कोड करता है। एक स्ट्रिंग शुरू करने के लिए D, पहले 8 बिट्स होने चाहिए 0x44; बाकी कोई बात नहीं है, लेकिन जब से हमें हर चरित्र को दोहराना है, 12 वीं से 20 वीं बिट्स भी होने जा रहे हैं 0x44। इस प्रकार, हमारे पास 0x44n44nकुछ एन के लिए फॉर्म का मूल्य होगा , जो तीन बाइट्स में विघटित होता है 0x44 0xn4 0x4n।

के लिए oहै, जो 0x6Fहै, हम बाइट्स मिलता 0x6F 0xn6 0xFn।

जब से मैं आलसी हूं, मैंने एन्कोडिंग द्वारा शुरू किया "DDDooo nnnooottt (etc.)"और फिर हर दूसरे चरित्र को पिछले के साथ बदल दिया, यही वजह है कि मुझे 0x444444= "DDD"के लिए Dऔर 0x6F66F6= के "of�"लिए मिलता है o। �वहाँ है, क्योंकि 0xF6अपने आप में अवैध UTF-8 एन्कोडिंग है।

अब, कार्यक्रम पर वापस जाएं। कार्यक्रम का शेष भाग निम्नानुसार है:

The - स्ट्रिंग को धक्का देता है ".\"�"

鎵 remov - अंतिम चरित्र को दो बार हटाता है, हमें छोड़कर "."

Ates - दो डुप्लिकेट। ढेर अब:[".", ".", "."]

合 conc - दो बार समवर्ती। ढेर अब:["..."]

अब, मैं आगे जो करना चाहता हूं वह "..."एक नियमित अभिव्यक्ति के रूप में उपयोग किया जाता है ताकि मैं एक बार में मूल स्ट्रिंग से तीन वर्णों का मिलान कर सकूं, using ... to लूप निर्माण। हालाँकि, प्रत्येक निर्देश को डुप्लिकेट करने के बाद, मुझे दो ऐसे नियमित-अभिव्यक्ति लूप्स एक दूसरे के अंदर नेस्टेड करने की आवश्यकता होती है , और यदि स्टैक कम हो जाता है तो मुझे एक रनटाइम त्रुटि मिलती है। इसलिए,

Empty - खाली स्ट्रिंग को दो बार धक्का दें

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

標 push - स्टैक पर दो निशान धकेलें। ढेर अब:[mark mark]

現 push - वर्तमान रेगेक्स मैच की दो प्रतियां धक्का। ढेर अब:[mark mark "DDD" "DDD"]

併 conc - पहले निशान तक समतल। ढेर अब:["DDDDDD"]

Character - उस तार का पहला वर्ण लें, और फिर (अतिरेक से) उस का पहला वर्ण। स्टैक में अब वह चरित्र है जो हम चाहते हैं।

आंतरिक लूप यहां समाप्त होता है, इसलिए नियमित अभिव्यक्ति के प्रत्येक मैच को उस मैच के पहले चरित्र से बदल दिया जाता है। यह स्टैक पर वांछित स्ट्रिंग छोड़ देता है।

फिर बाहरी लूप समाप्त होता है, जिस बिंदु पर वांछित स्ट्रिंग को स्टैक से हटा दिया जाता है ""और स्ट्रिंग में एकमात्र मैच को ""इसके साथ बदल दिया जाता है, वांछित स्ट्रिंग को एक बार फिर से स्टैक पर छोड़ दिया जाता है।

— Timwi
स्रोत

3

उम्म ... आपने यहाँ कोड प्रारूप का उपयोग क्यों नहीं किया? क्या यह चीनी अक्षर है?

— आउटगॉल्फ

@EriktheOutgolfer मैं एक ही बात सोच रहा था (और वे कोरियाई पात्र हैं, चीनी नहीं)।

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

@ केविनक्रूजसेन मुझे लगता है कि इसमें कुछ चीनी पात्र भी हैं। वास्तव में, युक्ति का कहना है कि यह निर्देशों के लिए डेटा और चीनी के लिए हंगुल का उपयोग करता है।

— आउटगोल्फर

@EriktheOutgolfer आह, आप वास्तव में सही हैं। मुझे rtfm होना चाहिए .. :)

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

12

भूलभुलैया , 528 बाइट्स

66))__vv          ..33::00&&__vv          ..44__99||__vv          ..33::00&&__vv            ..99))__vv            ..99))__vv      ..44__88$$__vv          ..22__99++__vv          ..22__99$$__vv            ..22__99))$$__vv      ..33__77$$__vv            ..33__vv

      ..44__99||__^^          ..11__99++__^^          ..44__88$$__^^          ..44((__88$$__^^      ..11))__99++__^^      ..99((__^^          ..33::00&&__^^          ..44__99||__^^          ..44((__88$$__^^            ..99))__^^          ..11__99$$((__^^    ..@@

xx

डबल न्यूलाइन्स को चोट लगी है, लेकिन कम से कम यह साबित होता है कि यह उल्लेखनीय है!

प्रत्येक चरित्र को एक-एक करके मुद्रित किया जाता है, पहले कोड बिंदु का निर्माण करके फिर एक चार्ट को प्रिंट किया जाता है। कोड बिंदु निम्न द्वारा बनते हैं:

D 68  66))
o 111 44__99||
  32  33::00&&
n 110 11__99++
t 116 44__88$$
r 114 44((__88$$
e 101 99))
p 112 11))__99++
a 97  99((
y 121 22__99++
u 117 22__99$$
s 115 22__99))$$
l 108 33__77$$
f 102 11__99$$((
! 33  33

कहाँ पे

)(        Increment/decrement by 1 respectively
&|$       Bitwise AND/OR/XOR respectively
+         Add
:         Duplicate
_         Push zero
0-9       Pop n and push n*10+<digit>

भूलभुलैया के अंकों के असामान्य व्यवहार का शोषण किया जाता है 33::00&&, जो वास्तव में है

[33] -> [33 33] -> [33 33 33] -> [33 33 330] -> [33 33 3300] -> [33 32] -> [32]
     :          :             0              0               &          &

हर एक चर को तंत्र के साथ मुद्रित किया जाता है

__vv

  ..

xx

xxकेवल पैड के लिए ग्रिड मौजूद इतना है कि यह 5 उच्च है। पहले __पुश दो शून्य, फिर हमने एक ग्रिड रोटेशन ऑपरेटर को मारा v। हम एक शून्य पॉप करते हैं और घुमाते हैं:

__ v
  v
   .
  .
xx

और फिर:

__ v

  v.

xx.

हम फिर .तीसरी पंक्ति पर दाईं ओर बढ़ते हैं , इस प्रकार प्रिंट कमांड को केवल एक बार निष्पादित करते हैं।

— Sp3000
स्रोत

मुझे उस ट्रिक से प्यार है जो आपने प्रिंट कमांड को केवल एक बार निष्पादित करने के लिए किया था। यह बहुत चालाक है।

— तिमवी

11

सीजेएम - 176 136 बाइट्स

66))HH77++GG00++BB88++HH77++EE88++GG00++DD88++99))CC88++99))AA77++EE88++GG00++BB99++HH77++KK77++DD88++JJ77++99))AA88++II66++33]]{{cc}}//

मेरे कार्यक्रम के आकार को दो से विभाजित करने के लिए Sp3000 का धन्यवाद :-)

व्याख्या

कोड HH77++, GG00++... संख्याओं को जोड़कर पूर्णांक ascii वर्णों की गणना करते हैं (उदाहरण के लिए: `HH77 ++ 'स्टैक पर 17, 17 और 77 धक्का देता है, फिर इन 3 संख्याओं को जोड़ें)
कोड के भाग ]]{{cc}}//को एससी कोड के माध्यम से छोरों पर ले जाता है और उन्हें वर्णों में परिवर्तित करता है।

इसे यहाँ आज़माएँ

— अरनॉड
स्रोत

1

क्या आपने इसे एक कार्यक्रम के साथ उत्पन्न किया? बहुत कम से कम, बहुत अंत हो सकता है 33cc, लेकिन मुझे यकीन है कि कुछ अन्य लोगों के लिए बेहतर तरीके हैं

— Sp3000

@ Sp3000 हाँ, बस एक प्रोग्राम चलाया जिसमें ++ के साथ विभिन्न संयोजनों की कोशिश की गई। मैंने अन्य ऑपरेटरों की कोशिश नहीं की है ...

— अरनौद

3

एक और नोट: ccहर जगह के बजाय , ]]{{cc}}//अंत में करें

— Sp3000

11

स्व-संशोधित ब्रेनफ *** , 72 बाइट्स

ध्यान दें कि \x00एक शाब्दिक NULहेक्स बाइट (खाली सेल) का प्रतिनिधित्व करता है । स्रोत कोड को टेप पर रखा गया है, जो शुरुआती सेल से बचा हुआ है।

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD\0\0<<<<<<++[[<<]]<<[[..<<]]

व्याख्या

!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD  The string on the tape for easy printing
\x00\x00                                        A separator to make printing shorter
<<<<<<++                                        Change first '.' to '0' (comment)
[[<<]]<<                                        Move to separator, then left to string
[[0.<<]]                                        Print string

इसके अलावा, इस कार्यक्रम को बनाने से पहले, मैं स्रोत में केवल बीएफ पात्रों का उपयोग करके एक बना रहा था। यह संभव है! यह बहुत लंबा है, क्योंकि विषम ASCII मूल्य के लिए, मैं दोगुना मूल्य बनाने जा रहा था, फिर दो से विभाजित करें। थोड़ा छोटा होने के साथ शुरू करने के लिए विषम मान उत्पन्न करने के लिए पूरे स्रोत को संशोधित किया जाएगा।

— mbomb007
स्रोत

क्या यह आउटपुट DDoo nnoott rreeppeeaatt yyoouurrsseellff!!(डबल स्पेस) नहीं होगा? मैं दो .एस देखता हूं ।

— आउटगॉल्फ

@EriktheGolfer समय आपके लिए मेरे उत्तर को पढ़ने के लिए। Change first '.' to '0'। मैंने स्पष्टीकरण को फिर से दिखाने के लिए बदल दिया है कि पहले .को एक शून्य में बदल दिया गया है।

— mbomb007

7

जैली , 66 बाइट्स (गैर-प्रतिस्पर्धात्मक)

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!””ṛṛḷḷWWQQ€€

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

factoid

यदि आप प्रत्येक दूसरे वर्ण को निकालते हैं, तो भी यह प्रोग्राम काम करता है।

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

यह काम किस प्रकार करता है

““DDoo  nn““oott  rreepp““eeaatt  yyoouurrss““eellff!!”

स्ट्रिंग की एक सरणी देता है। शाब्दिक एक के साथ शुरू होता है “, एक के साथ समाप्त होता है ”, और तार आंतरिक रूप से सीमांकित होते हैं “। परिणाम है

["", "DDoo  nn", "", "oott  rreepp", "", "eeaatt  yyoouurrss", "", "eellff!!"]

लिंक का तर्क और रिटर्न मान स्ट्रिंग के इस सरणी पर सेट किए जाते हैं, फिर शेष स्रोत कोड निष्पादित किया जाता है।

<literal>”ṛṛḷḷWWQQ€€  Argument/return value: A (string array)

         ”ṛ           Yield the character 'ṛ'.
           ṛ          Select the right argument of 'ṛ' and A: A.
            ḷ         Select the left argument of A and A: A.
              W       Wrap; yield [A].
             ḷ        Select the left argument of A and [A]: A.
               W      Wrap; yield [A].
                Q     Unique; deduplicate [A]. Yields [A].
                 Q€€  Unique each each; for each string s in A, deduplicate s.

— डेनिस
स्रोत

गैर-प्रतिस्पर्धा क्यों?

— ४

1

क्योंकि जेली दिसंबर 2015 में बनाई गई थी, इसलिए यह इस चुनौती को तीन महीने तक स्थगित कर देती है।

— डेनिस

उफ़, यह समझ में नहीं आया कि यह एक पुरानी चुनौती है

— 14

5

गैम्प्लेक्स , 66 बाइट्स

\\

XX""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""XXXXrrRREE

गैम्प्लेक्स एक 2 डी भाषा है जो लाइन की लंबाई के रूप में पहली न्यूलाइन की स्थिति का उपयोग करती है, और अन्य सभी न्यूलाइन्स को अनदेखा करती है।

— jimmy23013
स्रोत

5

MSM , 270 160 बाइट्स

!!'',,ff'',,ll'',,ee'',,ss'',,rr'',,uu'',,oo'',,yy'',,  '',,tt'',,aa'',,ee'',,pp'',,ee'',,rr'',,  '',,tt'',,oo'',,nn'',,  '',,oo'',,DD'',,......................

मेरा पहला एमएसएम कार्यक्रम!

MSM में स्ट्रिंग आउटपुट व्यक्तिगत पात्रों को स्टैक पर धकेल कर और उन्हें एक स्ट्रिंग के माध्यम से जोड़कर किया जाता है ., जैसे

!olleH.....

की संख्या .वर्णों की संख्या से एक कम है। क्योंकि Do not repeat yourself!हमें 22 .एस चाहिए। सौभाग्य से यह एक सम संख्या है, इसलिए हमारे पास 11 युगल हैं

......................

इसके सामने अक्षरों को रखने के लिए कुछ और प्रयास की आवश्यकता होती है। पैटर्न

cc'',,

प्रत्येक चरित्र के लिए चाल है c। इसका मूल्यांकन इस प्रकार है

cc'',,            push c (remember: commands are taken from the left and operate on the right)
c'',,c            push c
'',,cc            quote ' and push
,,cc'             pop
,cc               pop
c                 voilà!

हमें ऐसी 23 प्रतिमानों की आवश्यकता है जिनके साथ शुरुआत !!'',,और समापन DD'',,22 कमांड के साथ होता है .।

— nimi
स्रोत

5

Befunge 98, 70 66 बाइट्स

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

मेरे अमान्य जवाब के बाद, यहां एक बेहतर है जो वास्तव में चुनौती के लायक है!

2200**xx""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD��""kk,,@@

( ��इसके बजाय, चरित्र 0x17 के उपयोग के सुझाव के लिए मार्टिन एंडर का धन्यवाद 88ff++)

व्याख्या:

2200          Push 2, 2, 0, and 0 onto the stack
*             Multiply 0 and 0, yielding 0
*             Multiply 2 and 0, yielding 0
              The stack is now [2, 0]
x             Pop a vector off the stack and set the instruction pointer delta to that
              The instruction pointer is now skipping over every other character, since the delta is (2, 0)
"!f ... oD�" Push the string onto the stack, with the number 23 (number of characters in the string) at the top
k,            Pop characters off the stack and print them, 23 times
@             End the program

— Hactar
स्रोत

आप स्ट्रिंग के अंदर एक unprintable character (कोड पॉइंट 23) का उपयोग करके चार बाइट्स बचा सकते हैं 8f+: tio.run/nexus/…

— मार्टिन

4

डीसी , 348 346 342 306 290 278 बाइट्स

फ़ाइल dnr6.short.dc(नई अनुगामी के बिना):

AAzz--22222222vvPPAAAAAAAAvvPP88vvFFFFFFFFvv00++AAzz--PP11vvFFFFFFFFvv00++AAAAAAvvPP11vvEEEEEEEEvv00++OOOO//44999999vv++PP77II++OOOO//44999999vv++PPAAAAAAvv88vvFFFFFFFFvv00++PPAAzz--BBPP11vvFFFFFFFFvv00++77OOOO++++PPOOOO//44999999vv++66vvFFFFFFFFvv00++PP99zz++OO88++PPAAAAvv33PP

Daud:

$ dc < dnr6.short.dc 
Do not repeat yourself!

— हिममानव
स्रोत

3

बॉटजाइन , 6x49 = 294

vv  PP

  !!ee

  ffee

  llee

  eeee

  ssee

  rree

  uuee

  ooee

  yyee

    ee

  ttee

  aaee

  eeee

  ppee

  eeee

  rree

    ee

  ttee

  ooee

  nnee

    ee

  ooee

  DDee

>>  ^^

— SuperJedi224
स्रोत

3

बैकहैंड , 54 बाइट्स

vv""!!fflleessrruuooyy  ttaaeeppeerr  ttoonn  ooDD""HH

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

चूंकि बैकहैंड का पॉइंटर पहले से ही तीन कोशिकाओं पर टिक कर चल रहा है, हमें केवल 2 का उपयोग करते हुए घटाना है v

— मजाक कर रहा है
स्रोत

2

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

2200**UU""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""oo;;

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

भागों में स्पष्टीकरण:

2200**
2200    the stack looks like [2 2 0 0]
    *   [2 2 0*0]
     *  [2 2*0*0]
        [2 0]

Ux- इकाइयों और y- इकाइयों को (2, 0)ले जाने के लिए सूचक दिशा सेट करता है , इसलिए यह हर दूसरे वर्ण को छोड़ देता है, अगले से शुरू होता है20U को छोड़ देता है स्किड । फिर, प्रत्येक अन्य वर्ण रिकॉर्ड किया जाता है, और यह इसके बराबर है:

"Do not repeat yourself!"o;

जो एक साधारण आउटपुट प्रोग्राम है।

अन्य

यह वैलीवेस्ट के जावास्क्रिप्ट इनाम के लिए प्रतिस्पर्धा कर रहा है:

मैं यह साबित कर सकता हूं, जबकि इस प्रतिबंध के तहत संख्या का निर्माण किया जा सकता है, तार नहीं हो सकते। चूंकि किसी भी शाब्दिक का उपयोग नहीं किया जा सकता है, क्योंकि किसी भी शाब्दिक-निर्माण चरित्र की नियुक्ति एक खाली स्ट्रिंग बनाएगी:

""
''
``

फिर, केवल कुछ ऑपरेटर का उपयोग किया जा सकता है; केवल "युग्मित" ऑपरेटरों का उपयोग किया जाता है:

++ -- << >> ** ~~ || && !! ==

और इनमें से कोई भी संख्या / अन्य लोगों को तार नहीं दे सकता है। तो कोई तार आउटपुट नहीं किया जा सकता है।

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

5 दिन में बाउंटी खत्म, @ConorOBrien, आशा है कि आप इंतजार नहीं करेंगे! लेकिन ईनाम आपका है।

— वैलीवेस्ट

2

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

aa00tt,,JJ""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!//@@""ooYY;;tt

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

व्याख्या

पहली पकड़ यह है कि हमें स्ट्रिंग में प्रवेश करने में सक्षम होने की आवश्यकता है, इसलिए हम केवल पहले को छोड़ना चाहते हैं "। हम इसे पहली बार कूद कर करते हैं "क्योंकि तब आईपी एक सेल को चालू सेल को फिर से देखने से पहले ले जाएगा, ताकि यह दूसरा हो "जो स्ट्रिंग मोड में प्रवेश करता है। लेकिन वहां कूदने में सक्षम होने के लिए, हमें 10, 0स्टैक के शीर्ष पर, उस क्रम में (दूसरा, शीर्ष) की आवश्यकता है। इसके साथ किया जाता है aa00tt,,:

                          Stack:
aa   Push two 10s.        [... 10 10]
00   Push two 0s.         [... 10 10 0 0]
tt   Decrement twice.     [... 10 10 0 -2]
,    Rotate(-2).          [... 0 10 10]
,    Rotate(10).          [... 0 10 0]

यह रोटेशन फ़ंक्शन एक तर्क को पॉप करता है। यदि वह तर्क नकारात्मक है, तो यह कई पदों के नीचे स्टैक के शीर्ष पर मूल्य को धक्का देता है। यदि तर्क सकारात्मक है, तो यह उस तत्व की तलाश में चला जाता है जो शीर्ष के नीचे कई स्थान रखता है और इसे ऊपर तक खींचता है। ध्यान दें कि Rotate(10)स्टैक पर पर्याप्त तत्व नहीं हैं, लेकिन निचले हिस्से में शून्य की एक अंतर्निहित अनंत राशि है, यही कारण है कि एक शून्य शीर्ष पर समाप्त होता है।

अब हम इन दो तर्कों का उपयोग करते हुए Jपहली बार अंपायरिंग कर सकते हैं "। दूसरा "स्ट्रिंग मोड में प्रवेश करता है और उस सभी को रिकॉर्ड करता है DDoo nnoott...। जब यह हिट होता है /, तो आईपी को दक्षिण-पूर्व में पुनर्निर्देशित किया जाता है और हम साधारण मोड में प्रवेश करते हैं। अभी के लिए IP तीन रेखाओं (जिनमें से दो खाली हैं) के ऊपर और नीचे उछलता है, इसलिए यह पहली बार लाइनों दो और तीन पर तीन और रिक्त स्थान दर्ज करता है और जब हम हिट करते हैं तो हम स्ट्रिंग मोड छोड़ देते हैं "। चूंकि हम इस समय ऑर्डिनल मोड में हैं, सभी रिकॉर्ड किए गए वर्णों को स्टैक के एकल स्ट्रिंग के रूप में धकेल दिया जाता है (भले ही हमने उनमें से अधिकांश को कार्डिनल मोड में रिकॉर्ड किया है), इसलिए हम इस स्ट्रिंग के साथ समाप्त होते हैं (अनुगामी रिक्त स्थान पर ध्यान दें) :

DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!

अब आईपी ऊपर उछल रहता है और जो नीचे मतलब है कि यह हर दूसरे जोड़ी, यानी में से एक आदेश निष्पादित करता है Yऔर t। फिर आईपी दूसरी पंक्ति पर ग्रिड के अंत को हिट करेगा और ग्रिड के माध्यम से पीछे की ओर उछलना शुरू कर देगा। यह भी स्विच करता है जिसमें आईपी के पात्रों की जोड़ी पहली पंक्ति को हिट करती है, इसलिए जब वापस जा रही है तो यह निष्पादित होता है ;, oऔर @। इसलिए सभी रिक्त स्थान और अंतर्निहित आईपी पुनर्निर्देशन को अनदेखा करते हुए, निष्पादित कोड Yt;o@ऑर्डिनल मोड में है।

Y"Unzip" कमांड जो बारी पदों में पात्रों में एक स्ट्रिंग अलग करती है। चूँकि प्रत्येक वर्ण दोहराया जाता है, यह वास्तव में हमें स्ट्रिंग की दो प्रतियाँ देता है, जिसके लिए हम जा रहे हैं, हालाँकि पहली प्रति में दो अनुगामी स्थान होते हैं और दूसरी में एक अनुगामी स्थान होता है। tउस अनुगामी स्थान को विभाजित करता है और उसे ;त्याग देता है। अंत में, oस्ट्रिंग को प्रिंट करता है और @प्रोग्राम को समाप्त करता है।

— मार्टिन एंडर
स्रोत

2

05AB1E , 100 58 52 बाइट्स

-6 बाइट्स केविन क्रूज़सेन को धन्यवाद

„„€€··™™……€€––  ……¹¹‚‚  ……––‚‚))εε##θθáá}}»»……!!θθJJ

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

„„€€·              # dictionary string "g do"
     ·             # double (no effect on strings)
      ™            # title case: "G Do"
       ™           # title case again (no effect)
……€€––             # dictionary string "tools not–"
                   # spaces necessary so "–…" isn't parsed as a dictionary word
……¹¹‚‚             # dictionary string "team repeat‚"
                   # spaces necessary again
……––‚‚             # dictionary string "j yourself‚"
)                  # wrap the entire stack in an array
 )                 # and again: [["G Do", "tools not–", "team repeat‚", "j yourself‚"]]
  ε        }       # for each:
   ε      }        #  for each:
    #              #   split on spaces: ["tools", "not–"]
     #             #   and again: [["tools", "not–"]]
      θ            #   get the last element: ["tools", "not–"]
       θ           #   and again: "not–"
        á          #   keep only letters: "not"
         á         #   and again (no effect)
            »      # join the list by newlines, joining sublists by spaces:
                   # "Do not repeat yourself"
             »     # join the stack by newlines, joining lists by spaces (no effect)
……!!               # literal string "…!!"
    θ              # get the last character: "!"
     θ             # and again (no effect)
      J            # join the stack without separators: "Do not repeat yourself!"
       J           # and again (no effect)
                   # implicit output

निष्पत्ति नियम।

— साँवला
स्रोत

1

अच्छा जवाब, मैं प्रभावित हूँ कि आप इस तरह से शब्दकोष में निचोड़ने में सक्षम थे! यह दुर्भाग्य है कि áयह आंतरिक तारों पर वेक्टर नहीं करता है, अन्यथा इसका उपयोग किया जा सकता है )).. सभी को हटाने áऔर वैकल्पिक के रूप εεáá}}में ))काम करने के बाद उपयोग किया जा सकता है , लेकिन दुर्भाग्य से यह किसी भी बाइट को बचाता नहीं है (लेकिन शायद आप इससे प्रेरणा पा सकते हैं? ) .. और काम के „„!!बजाय के ……!!रूप में अच्छी तरह से, के रूप में !अंतर्निहित एक ही तार छोड़ देता है। आह ठीक है, मैंने कोशिश की। xD

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

1

@KevinCruijssen मैं ##θθááथोड़ी देर के लिए उन लोगों को फिर से भरने की कोशिश कर रहा हूं , और किसी कारण से मैंने विचार नहीं किया εε}}... मैंने कोशिश की €€, जो काफी काम नहीं करता है ... यह अब सबसे छोटा जवाब है, धन्यवाद!

— 13

1

स्टैक्स , 70 बाइट्स

GG11hh::zzaapp..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

भागो और इसे staxlang.xyz पर डीबग करें!

स्टेक्स बहुत सौभाग्य से ::प्रत्येक-एनटीएच के लिए बिलिन है। मुझे केवल स्ट्रिंग को दोगुना करने, 2 पुश करने और चलाने की आवश्यकता है ::। आसान है, है ना?

गलत।

उस स्ट्रिंग को धक्का देना मुश्किल है। पहले उद्धरण चिह्न को दोगुना किया जा सकता है .."", जो ."कि एक सार्थक उद्धरण चिह्न के बाद की लंबाई -2 है । समस्या यह है, मुझे एक नया शुरू किए बिना स्ट्रिंग को समाप्त करने का कोई तरीका नहीं दिखता है (जो आवश्यक है, या अन्यथा दोहरा संस्करण मुद्रित किया जाएगा)।

कार्यक्रम का अंत स्ट्रिंग शाब्दिकों को समाप्त करता है। अगर मैं इस दोगुने शाब्दिक को वहां रख सकता हूं, तो शायद एक अच्छा समाधान होगा। एक कार्यक्रम के अंत से कहीं कूदने के लिए, हालांकि, आवश्यकता होती है G}, इसलिए कम से कम, मैं इसे देख रहा हूं:

GG [deduplicate] }}""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

यह करता है ... कुछ नहीं। Gएक ब्लॉक शुरू नहीं करता है, इसलिए न तो दूसरे पर कूद जाएगा }। फिर से, मुझे एक चरित्र को अनदेखा करने की आवश्यकता है ..}}:। निष्पादन पहले Gसे दूसरे }तक कूदता है, अंत तक जारी रहता है, दूसरे Gसे वापस कूदता है और वहां से दूसरे तक जाता है }, और [deduplicate]स्टैक के ऊपर दोहरी स्ट्रिंग के साथ अनुभाग की शुरुआत में फिर से शुरू होने से पहले एक बार और अंत तक जारी रहता है ।

Deduplication सरल है। 11hhधक्का दिया ग्यारह और इसे दो बार आधा कर देता है, दोनों बार नीचे चक्कर लगाता है और दो उपज देता है, और ::फिर हमें वह आउटपुट मिलेगा जो हमें चाहिए।

GG11hh::..}}..""DDoo  nnoott  rreeppeeaatt  yyoouurrsseellff!!""

उह ओह। यह प्रिंट कुछ भी नहीं है। यहां दो समस्याएं हैं: पहला, ..}इसका मतलब है कि स्ट्रिंग .}कार्यक्रम के अंत में स्टैक के ऊपर होगी, और दूसरा, स्टैक्स का साधारण निहितार्थ आउटपुट अब अक्षम हो गया है!

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

हम या तो की आवश्यकता होगी ppया PP, और इस उदाहरण में, के माध्यम से पहली अनदेखी ..pp, अस्वीकार्य है के रूप में यह स्ट्रिंग प्रिंट होगा .p। इसका मतलब है कि हमें खाली स्टैक के साथ ही स्टैक पर या शीर्ष दो में हमारे वांछित आउटपुट की आवश्यकता है। यह उत्तरार्द्ध दो खाली तारों को धक्का देकर ( zzऔर aaमुद्रण से पहले दो बार ) शीर्ष तीन वस्तुओं को घुमाकर पूरा किया जाता है ।

एक बार ऐसा करने के बाद, हमारे पास एक स्टैक चार तार लंबा होता है। एक पांचवें, .}फिर कार्यक्रम को शान से बाहर निकलने से पहले धकेल दिया जाता है; इस बिंदु पर, निहित आउटपुट की कमी एक आशीर्वाद के साथ-साथ एक अभिशाप बन जाती है, क्योंकि अतिरिक्त कुछ भी अब मुद्रित नहीं होगा!

— खुल्द्रेसथ न’बैरी
स्रोत

बस खुद को दोहराएं

उदाहरण

सत्यापन

हेक्सागोनी , 166 126 124 बाइट्स

यह काम किस प्रकार करता है

गोल्फस्क्रिप्ट, 130 84 76 बाइट्स

यह काम किस प्रकार करता है

यूनरी , ~ 1.86 × 10 222

रूबी - 2100 1428 1032 820 670 बाइट्स

> <> , 174 बाइट्स

स्किलिंग , 186 146 बाइट्स

व्याख्या

भूलभुलैया , 528 बाइट्स

सीजेएम - 176 136 बाइट्स

स्व-संशोधित ब्रेनफ *** , 72 बाइट्स

व्याख्या

जैली , 66 बाइट्स (गैर-प्रतिस्पर्धात्मक)

factoid

यह काम किस प्रकार करता है

गैम्प्लेक्स , 66 बाइट्स

MSM , 270 160 बाइट्स

Befunge 98, 70 66 बाइट्स

डीसी , 348 346 342 306 290 278 बाइट्स

बॉटजाइन , 6x49 = 294

बैकहैंड , 54 बाइट्स

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

अन्य

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

व्याख्या

05AB1E , 100 58 52 बाइट्स

स्टैक्स , 70 बाइट्स

यूनरी , ~ 1.86 × 10 ²²²