द क्वीन का महान पिरामिड

11

कार्य एक मोड़ के साथ एक सरल सरल चुनौती है, आपको अपने स्रोत कोड को पिरामिड के आकार में आउटपुट करना होगा। पिरामिड का आकार नीचे परिभाषित किया गया है:

       1
      234
     56789
    ABCDEFG
   HIJKLMNOP
  QRSTUVWXYZa
 bcdefghijklmn
......etc......

इस चुनौती की मुख्य सीमा यह है कि आपकी क्वीन में पिरामिड की तर्ज पर बाधा न डालने के लिए बिल्कुल पर्याप्त बाइट्स होने चाहिए। उदाहरण के लिए, निम्नलिखित प्रोग्राम की लंबाई काम करेगी:

1-byter: 1st layer of the pyramid (not allowed by definition of a quine).
4-byter: 1st and 2nd layers of the pyramid.
9-byter: 1st, 2nd and 3rd layers of the pyramid.
etc...

तो, अगर आपका कार्यक्रम था:

QWERTY

यह मान्य नहीं होगा, क्योंकि यह इस तरह की व्यवस्था करेगा:

  Q
 WER
TY

हालाँकि, यदि आपका प्रोग्राम QWERTYUIO था, तो यह ठीक होगा:

  Q
 WER
TYUIO

नियम

  • मानक खामियों को स्पष्ट रूप से अस्वीकार कर दिया जाता है, कोई भी अपने स्रोत को नहीं पढ़ता है।
  • पिरामिड को केंद्रित करना चाहिए, अनुगामी पात्रों को अनुमति दी जानी चाहिए, लेकिन आवश्यक नहीं।
    • इसके अलावा, किसी भी वर्ण का उपयोग पिरामिड को केन्द्रित करने के लिए किया जा सकता है, होना नहीं चाहिए (char)32।
  • आपकी रानी को एक पिरामिड में आकार देने में सक्षम होना चाहिए।
    • इसे अपने सोर्सकोड के मूल क्रम को बनाए रखना होगा।
    • आपके स्रोत-कोड में पिरामिड को प्रारूपित करने के लिए इस्तेमाल किया जा रहा चरित्र नहीं हो सकता है ।
    • ईजी यदि आपके सोर्सकोड में स्थान है, तो आपको प्रारूप के लिए एक और चार्ट की आवश्यकता होगी।
  • आप अपने क्वीन में "पैड" के लिए सही आकार में टिप्पणियों का उपयोग कर सकते हैं।
    • जाहिर है, ये क्वीन के हिस्से के रूप में आउटपुट होना चाहिए।
  • यदि प्रोग्राम में newlines / tabs हैं, तो वे क्वीन का हिस्सा नहीं हैं और आउटपुट में छोड़ा जाना चाहिए।
  • आकृति पात्रों में गिनी जाती है, बाइट्स नहीं; यदि आकार विकृत है, तो आप इसे सही नहीं कर रहे हैं।

यहां सबसे कम संभव स्कोर 4 होना चाहिए।

code-golf  ascii-art  restricted-source  quine 
— जादू ऑक्टोपस Urn
स्रोत
क्या मूल क्वीन को पिरामिड के आकार में होना चाहिए, या क्या सिर्फ आउटपुट की आवश्यकता है?
— KrystosTheOverlord
@KrystosTheOverlord आउटपुट, मूल कोई फर्क नहीं पड़ता। यदि मूल में टैब या न्यूलाइन हैं, तो आपको आउटपुट के आकार को बनाए रखने के लिए आउटपुट में इनको छोड़ देना चाहिए।
— मैजिक ऑक्टोपस Urn
यदि आउटपुट में अनुगामी रिक्त स्थान / न्यूलाइन्स का एक समूह है, तो क्या यह मान्य है?
— 18
@ ईमनिग्ना होना चाहिए? जब तक अन्य इस बिंदु पर नहीं करते, मुझे इसके साथ कोई समस्या नहीं दिखती। इसके अलावा, "एक गुच्छा" को परिभाषित करें, क्या आम तौर पर आम सहमति नहीं है "एक एकल अनुगामी न्यूलाइन स्वीकार्य है"?
— मैजिक ऑक्टोपस Urn
1
आपको एक चुनौती बनानी चाहिए जहां आपको पिरामिड के प्रारूप में क्वीन की आवश्यकता है :)।
— KrystosTheOverlord

जवाबों:

4

05AB1E , 36 बाइट्स

"34çs«DJā·<£õK.cJ?"34çs«DJā·<£õK.cJ?

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

यदि trailing characters are allowedआउटपुट के अंत में भी इसका मतलब है, 0"D34çýā·<£.c"D34çýā·<£.c25 बाइट्स पर एक परत कम है।

— Emigna
स्रोत
34çसभी 05AB1E quines का आधार है, है ना? इसके अलावा, यह निश्चित नहीं है कि नई अनुगामी की यादृच्छिक मात्रा के बारे में मैं कैसा महसूस करता हूं ... मैं किसी और को उस कॉल को करना पसंद करूंगा (आदर्श क्या है, 1 अनुगामी / आगे बढ़ने की अनुमति है?) जो सुपर-ऑन-एज लगता है।
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn: हाँ, यह थोड़े संदिग्ध है। मुझे लगता है कि मेरा छोटा संस्करण ठीक नहीं है, यही वजह है कि मैंने इसे प्राथमिक कार्यक्रम के रूप में उपयोग नहीं किया, लेकिन मुझे लगा कि मुझे पूछना चाहिए क्योंकि यह मुझे पूरी परत बचाएगा।
— एमिगा
डांग, तुमने मुझे इसके लिए हराया। और इसके बजाय ā·<मैंने इस्तेमाल किया 9ÅÉ(25 बटर में, अनुगामी न्यूलाइन के बारे में नहीं सोचा था ..)
— केविन क्रूज़सेन
@MagicOctopusUrn Btw, अन्य सभी उत्तरों में एक अनुगामी न्यूलाइन है, इसलिए इस 36-
— बाय्टर
4

जावा 11, 324 256 227 बाइट्स

v->{var s="v->{vars=%c%s%1$c;for(inti=0;;)System.out.printf(%1$c%%%1$c+(15+i)+%1$cs%%n%1$c,s.format(s,34,s).substring(i*i,++i*i));}///";for(int i=0;;)System.out.printf("%"+(15+i)+"s%n",s.format(s,34,s).substring(i*i,++i*i));}//

-29 बाइट्स @JoKing की बदौलत ।

त्रिभुज बनाने के लिए अग्रणी स्थानों के साथ आउटपुट। (ध्यान दें कि व्हाट्सएप बीच है var sऔर int iटैब हैं, स्पेस नहीं।)

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

स्पष्टीकरण:

क्वीन -पार्ट :

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

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

for(int i=0;;)         // Loop `i` indefinitely upwards from 0
  System.out.printf(   //  Print with format:
    "%"+(15+i)+"s      //   Add leading spaces to make the line length size 15+`i`
                 %n",  //   And include a trailing newline
    s.format(s,34,s).substring(
                       //   And append a substring of the source code-String
       i*i,            //    From index `i` squared
       ++i*i));}       //    To index `i+1` squared

जो विधि के java.lang.StringIndexOutOfBoundsException: begin 225, end 256, length 226लिए एक त्रुटि के साथ बंद हो जाता है String#substring(int,int), इसके बाद पुनरावृति परिणाम मुद्रित किया जाता है ( जो मेटा के अनुसार ठीक है )।

— केविन क्रूज़सेन
स्रोत
यह आपको वास्तव में किसी भी चीज़ को नहीं बचाता है, लेकिन आपको s=s.formatतब भाग लेने की आवश्यकता नहीं है जब आप इसके बजाय लूप में प्रारूप रख सकते हैं
— जो किंग
@ जोकिंग आह। धन्यवाद। दुर्भाग्य से मुझे बाइट्स को बचाने के लिए कम से कम 196 (14 2) टिप्पणियों के बिना बेस प्रोग्राम को कम करना होगा (या केवल इसे 225 (15 2) पर गोल्फ करना होगा और किसी भी तरह की बाइट्स की एक विषम संख्या को हल करना होगा)। यह वर्तमान में टिप्पणियों के बिना 228 है।
— केविन क्रूज़सेन
1
एक अलग दृष्टिकोण की कोशिश की और केवल दो बाइट्स को समाप्त कर दिया और केवल एक विषम संख्या होने के कारण ... विषम लंबाई के लिए समाधान एक %%स्ट्रिंग में है और %वास्तविक कोड में केवल एक है, लेकिन इसका मतलब यह है कि टिप्पणियां अनिवार्य हैं
— जो राजा
1
@ जॉकिंग टैब के साथ बदले गए स्थानों के साथ अच्छा दृष्टिकोण ताकि हमारे पास अग्रणी स्थान हो (और चुनौती नियमों के कारण आउटपुट से टैब को छोड़ दें)। मैं ///स्ट्रिंग के साथ आपके कोड को फिर से काम करने में सक्षम हूं , इसलिए स्ट्रिंग इसके लिए पर्याप्त है ताकि अपेक्षित पुनरावृत्ति पर जाने के लिए सब कुछ प्रिंट हो सके, इसके StringIndexOutOfBoundsExceptionलिए स्टॉप के साथ पहले .substring। और //वास्तविक कार्यक्रम के अंत में केवल दो अनुगामी के साथ , क्योंकि यह केवल दो अनुगामी के //रूप में भी प्रिंट करता है। :)
— केविन क्रूज़सेन
अरे वाह, मुझे जावा उत्तर की उम्मीद नहीं थी! अच्छा है!!!
— मैजिक ऑक्टोपस Urn
4

पायथन 2 , 81 बाइट्स

s='n=0;\nprint(8-n)*chr(32)+("s=%r;exec(s*9)"%s)[n*n:][:n-~n];n+=1;#JK';exec(s*9)

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

एक eval quine जो फिलर कैरेक्टर के रूप में स्पेस का उपयोग करता है।

— मजाक कर रहा है
स्रोत
— केवल
— केवल
या ... अच्छी तरह से ... स्पष्ट रूप से बहुत अधिक पैडिंग के साथ आप इसमें एक हस्ताक्षर डाल सकते हैं (यानी एक अधिक दिलचस्प स्ट्रिंग thataaaaaaaaaa): P
— ASCII-only
@ ASCII- केवल अच्छा बिंदु, अपडेट किया गया उत्तर देखें;)
— Jo King
3

पर्ल 6 , 67 बाइट्स

<say("<$_>~~.EVAL".substr($!++²,$!*2-1).indent(8-$!))xx⁸>~~.EVAL

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

मैंने उस अतिरिक्त परत को निचोड़ने के लिए यूनिकोड के कुछ पात्रों का उपयोग किया। रिक्त स्थान का उपयोग कर आउटपुट:

       <
      say
     ("<$_
    >~~.EVA
   L".substr
  ($!++²,$!*2
 -1).indent(8-
$!))xx⁸>~~.EVAL

स्पष्टीकरण:

<say("<$_>~~.EVAL"                                  )   >~~.EVAL   # Normal quine
                  .substr($!++²,$!*2-1)              xx⁸  # Split into layered substrings
                                       .indent(8-$!)      # And indent each one
— मजाक कर रहा है
स्रोत
3

पायथन 2 , 169 बाइट्स

0पिरामिड को फॉर्मेट करने के लिए उपयोग करता है ।

s='s=%r;k=s%%s;print"\\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for n in range(13))#######################';k=s%s;print"\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for n in range(13))

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

पायथन 2 , 147 बाइट्स

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

s='s=%r;k=s%%s;print"\\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]forninrange(13))##';k=s%s;print"\n".join(`1-1`*(12-n)+k[n*n:][:n-~n]for	n	in	range(13))##

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

— OVS
स्रोत
2

गोल> <> , 36 बाइट्स

":P}r6&56F:M}F0ss|&:P&Roao{|;Nooooo!

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

एक भी छोटे संस्करण, 36 बाइट्स

":P}r6&56F:M}R` &:P&Fo|ao{|;Noooooo!

मैं इसे एक लाइन छोटी, grrrr प्राप्त करने के करीब महसूस करता हूं ...।

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

यहां तक ​​कि छोटे संस्करण, 36 बाइट्स

"r2ss6&56F:M}R` &:P&Fo|ao{|;what????

यह किसी का कोड छोटा है, लेकिन यह अभी भी उदासी से उसी राशि के लिए बाहर आता है, टिप्पणी शेष स्थान तक ले जाती है।

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

थोड़ा युवा संस्करण, 36 बाइट्स

"r2ss156F:M}F` o|:PP}Fo|ao{{|;Wowza!

Wowza! हे, मैंने अभी कुछ जगह भरने के लिए उपयोग किया है, लेकिन कार्यक्रम काम करता है, नीचे गोल्फ के लिए, मैंने चर का उपयोग करने के बजाय थोड़े पूर्वनिर्मित मूल्यों का उपयोग किया!

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

पुराने संस्करण, 42 बाइट्स

"r2ss0V_~6:&F&:M&F` o|_PPV_Fo|ao|;empty...

यह एक अनुगामी newline है, और मुझे पसंद है की तुलना में अधिक आकर्षण है ...

मैं इसे गंभीरता से गोल्फ होने जा रहा हूँ ...

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

— KrystosTheOverlord
स्रोत
— जो किंग
2

स्वच्छ , 256 बाइट्स

module QQ;import StdEnv,Text;q=dec'#';$n#k=(s<+q<+s<+q)%(n^2,n^2+n*2)=lpad k(16+n)(dec q);Start=join{toChar 10}(map$[0..15]);s="module QQ;import StdEnv,Text;q=dec'#';$n#k=(s<+q<+s<+q)%(n^2,n^2+n*2)=lpad k(16+n)(dec q);Start=join{toChar 10}(map$[0..15]);s="

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

बहुत ज्यादा मानक क्वीन, आसानी से एक टेम्पलेट क्वीन, स्वरूपण समारोह के साथ जोड़ा।

— Οurous
स्रोत
1
भले ही यह कोड-गोल्फ है, मुझे ये लंबे उत्तर पसंद हैं। पवित्र गाय जो प्रभावशाली हो।
— मैजिक ऑक्टोपस Urn
2

आर , 169 144 बाइट्स

s='`!`=intToUtf8;cat(sprintf("%*s",11+(i=1:12),substring(paste0("s=",q<-!39,s,q,";eval(parse(t=s))"),(i-1)^2+1,i^2)),sep=!010)';eval(parse(t=s))

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

           s
          ='`
         !`=in
        tToUtf8
       ;cat(spri
      ntf("%*s",1
     1+(i=1:12),su
    bstring(paste0(
   "s=",q<-!39,s,q,"
  ;eval(parse(t=s))")
 ,(i-1)^2+1,i^2)),sep=
!010)';eval(parse(t=s))

इसे एक स्ट्रिंग के पास ले जाकर छोटा करने का प्रबंधन किया गया है जो एक अभिव्यक्ति के बजाय छोड़ दिया गया है। हालांकि इसे 144 के तहत प्राप्त करने के लिए एक अपर संचालक के पुनर्वितरण का उपयोग करना था।

— निक केनेडी
स्रोत
1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 225 बाइट्स

var s="var s={0}{1}{0};for(int i=0;;)WriteLine(string.Format(s,(char)34,s).Substring(i*i++,2*i-1).PadLeft(i+14,(char)2));//";for(int i=0;;)WriteLine(string.Format(s,(char)34,s).Substring(i*i++,2*i-1).PadLeft(i+14,(char)2));//

एक का उपयोग करता है STXपैडिंग के रूप में चार का । मुझे एहसास नहीं हुआ कि केविन क्रूज़सेन ने पोस्ट करने से पहले ही जावा में एक सटीक प्रतिलिपि पहले ही जमा कर दी थी, लेकिन मैंने इस रास्ते को पोस्ट करने का फैसला किया।

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

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