वर्णमाला से बाहर सर्पिल!

13

निम्नलिखित स्ट्रिंग को देखें। एक पैटर्न नोटिस?

ABEFNOPEFGH
डीसी जीक्यूआई
MHRJ
LKJI एस.के.
DTL
वीर्य
BAZYXWV एन
ईओ
डी पी
सीक्यू
BAZYXWVUTSR

जैसा कि कुछ ने देखा होगा, यह मूल रूप से वर्णमाला का एक सर्पिल है, जहां पंक्तियों / स्तंभों के बीच की दूरी धीरे-धीरे 1 स्थान / न्यूलाइन से बढ़ रही है।

कठोर परिभाषा

  • चलो एक काउंटर सी है , जो शुरू में 0 है।
  • हम वर्णमाला के पहले c + 1 अक्षर को बाएं से दाएं लिखते हैं A:।

  • फिर, ऊपर से नीचे तक (सी + 1) (सी + 2) / 2 अक्षर (जोड़ें B) AB:।

  • बाएं से दाएं, अगला (c + 1) (c + 2) / 2 (add C):

    AB
 C

  • और नीचे से ऊपर तक, अगले सी + 1 अक्षर (जोड़ें D):

    AB
DC

  • चक्र के अंत तक पहुँच गया। इसलिए, चलो वेतन वृद्धि सी (जो 1 हो जाती है)। फिर, यह पहले चरण से वापस शुरू होता है, एकमात्र अंतर यह है कि वर्णमाला के पहले c + 1 अक्षरों का उपयोग करने के बजाय , हम अगले c + 1 अक्षरों का उपयोग करते हैं , जो इस चक्र के अंतिम तत्व से शुरू होता है ( Dइस मामले में, इसलिए हम जारी रखते हैं EFG...)। जब Zपहुंच जाता है, तो यह वापस से चक्र करता है A।

कार्य

एक पूर्णांक N (जो 1-अनुक्रमण के लिए सकारात्मक है या 0-अनुक्रमण के लिए गैर-ऋणात्मक है) को देखते हुए, सर्पिल के पहले N चक्र का उत्पादन करता है ।

नियम

  • आप या तो लोअरकेस या अपरकेस वर्णमाला का उपयोग कर सकते हैं, लेकिन आपकी पसंद सुसंगत होनी चाहिए (केवल उनमें से किसी एक का उपयोग करें, मिश्रण की अनुमति नहीं है)।

  • आप इनपुट ले सकते हैं और मानक तरीकों में से किसी भी प्रोग्रामिंग भाषा में आउटपुट प्रदान कर सकते हैं , जबकि यह देखते हुए कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

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

  • यह कोड-गोल्फ है , इसलिए बाइट्स (प्रत्येक भाषा में) में सबसे छोटा कोड जो आवश्यकताओं को पूरा करता है जीतता है!

परीक्षण के मामलों

इनपुट पूर्णांक को एक नई रेखा के माध्यम से इसके संबंधित आउटपुट से अलग किया जाएगा, और डैश का उपयोग करके परीक्षणों को अलग किया जाएगा। ध्यान दें कि ये 1-अनुक्रमित हैं।

1

एबी
डीसी

--------

2

ABEF
डीसी जी
एमएच
LKJI 

--------

3

ABEFNOP
डीसी जीक्यू
MHR
LKJI एस
डीटी
सीयू
BAZYXWV

-------

4

ABEFNOPEFGH
डीसी जीक्यूआई
MHRJ
LKJI एस.के.
DTL
वीर्य
BAZYXWV एन
ईओ
डी पी
सीक्यू
BAZYXWVUTSR

-------
5

ABEFNOPEFGHFGHIJ
डीसी जीक्यूआईके
MHRJL
LKJI SKM
DTLN
CUMO
BAZYXWV एनपी
EOQ
डीपीआर
CQS
BAZYXWVUTSR टी
आरयू
QV
पीडब्लू
OX
NMLKJIHGFEDCBAZY

------

6

ABEFNOPEFGHFGHIJSTUVWX
डीसी GQIKY
MHRJLZ
LKJI SKMA
DTLNB
CUMOC
BAZYXWV एनपीडी
EOQE
DPRF
CQSG
BAZYXWVUTSR TH
RUI
QVJ
PWK
OXL
NMLKJIHGFEDCBAZY एम
एस.एन.
आरओ
QP
पी क्यू
या 
NMLKJIHGFEDCBAZYXWVUTS
code-golf  string  ascii-art  alphabet 
— मिस्टर एक्सकोडर
स्रोत
मुझे लगता है कि testcases n = 1,2,3,5,6 होना चाहिए।
— TFeld

जवाबों:

9

चारकोल , 31 बाइट्स

Ｆ⮌…⁰ＮＢ⁺²⊘×ι⁺³ι⭆α§α⁺λ÷×ι⊕×ι⁺⁹⊗ι⁶

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नोट: deverbosifier किसी कारण से एक अनुगामी विभाजक का उत्पादन करता है। स्पष्टीकरण:

Ｆ⮌…⁰ＮＢ

आकार के रिवर्स ऑर्डर में बक्से ड्रा करें (सबसे छोटे से सबसे बड़े)।

⁺²⊘×ι⁺³ι

बॉक्स के आकार की गणना करें।

⭆α§α⁺λ

घुमाए गए वर्णमाला का उपयोग करके बॉक्स की सीमा बनाएं।

÷×ι⊕×ι⁺⁹⊗ι⁶

उस अक्षर की गणना करें जो बॉक्स के ऊपरी बाएँ (0-अनुक्रमित) पर दिखाई देगा।

— नील
स्रोत
6

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

n=input()
k=n*-~n/2+1
a=eval(`[[' ']*k]*k`)
x=y=z=0
for s in range(4*n+4):exec s/4*(s/4+1)/2*"if'!'>a[y][x]:a[y][x]=chr(z%26+65);z+=1\nx+=abs(2-s%4)-1;y+=s%2-s%4/3*2\n"
print a

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

व्याख्या

हम सही आकार के रिक्त स्थानों की एक खाली सरणी का निर्माण करते हैं, फिर ऊपर-बाएं कोने में शुरू करते हुए, इस तरह से आगे बढ़ते हैं:

  • 1 चरण →, 1 चरण step, 1 चरण step, 1 चरण step

  • 3 चरण →, 3 चरण steps, 3 चरण steps, 3 चरण steps

  • 6 चरणों →, 6 चरणों steps, 6 चरणों steps, 6 चरणों steps

  • 10 कदम →, 10 कदम steps, 10 कदम steps, 10 कदम steps

  • ...

हर बार जब हम एक रिक्त सेल पाते हैं, तो हम वहां एक अक्षर डालते हैं और वर्णमाला के अगले अक्षर पर चक्र लगाते हैं।

कोड में, s%4दिशा है (→ code ↑,), और हम इसे कई बार चरणबद्ध करते हैं:

TriangularNumber(s/4) = s/4*(s/4+1)/2.

गोल्फ के अवसर

  • वहाँ से नक्शा s%4करने के लिए एक छोटा रास्ता 1,0,-1,0है abs(2-s%4)-1?

  • वहाँ से नक्शा s%4करने के लिए एक छोटा रास्ता 0,1,0,-1है s%2-s%4/3*2?

क्रेडिट

  • मिस्टर एक्सकोडर ने एक बाइट को बचाया।
— लिन
स्रोत
2
+1 वाह, यह सिर्फ शानदार है। मुझे पता चला कि यह कैसे काम करता है। मुझे इसके लिए एक शॉर्टहैंड मिला 21/(s%4+3)%3-1: s%2-2*(s%4>2)( 179 बाइट्स )। यह अभी भी गोल्फ हो सकता है
— श्री एक्सकोडर
4

सी,  305  281 बाइट्स

@Mr को धन्यवाद। चार बाइट बचाने के लिए एक्सकोडर!

#define L(x,y)l[x][y]=a++%26+65;
#define F for(
c,i,j,a,p;f(n){char**l=calloc(8,i=a=n*n*4);F;i--;memset(l[i],32,a))l[i]=malloc(a);F c=a=p=i=0;c<n;++c){F i=p;i<c+p+!c;)L(j=0,c+i++)F p=i;j<=-~c*(c+2)/2;)L(j++,c+i)F;c+i-1;)L(j-1,c+--i)F i=0;i<=c;)L(j+~i++,0)}F i=0;i<j;)puts(l[i++]);}

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

— Steadybox
स्रोत
1
पहली बार मैं एक के #defineलिए देखता हूं for((जो वास्तव में बाइट्स बचाता है)। मुझ से +1। :)
— केविन क्रूज़सेन
2

पायथन 2 , 262 260 254 245 बाइट्स

lambda n:[[[' ',chr(65+(4*(i<j)+sum((i<j)*8+2+I*[5,9][i<j]+sum(2*R(I))for I in R(S(i,j)-1))+[i+j,-i-j][i<j])%26)][max(i,j)==S(i,j)*-~S(i,j)/2or i*j<1]for i in R(1+n*-~n/2)]for j in R(1+n*-~n/2)]
R=range
S=lambda x,y:int((8*max(x,y)+1)**.5+.99)/2

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

अधिक गणित के साथ नई विधि!

चार-सूचियों की सूची लौटाता है।

पुराना संस्करण:

पायथन 2 , 322 321 308 298 बाइट्स

R=range
n=input()
w=1+n*-~n/2;r=[w*[' ']for _ in R(w)];r[0][0]='A';l=R(1,w*w*9);c=lambda:chr(65+l.pop(0)%26)
for i in R(n+1):
 w=1+i*-~i/2;W=w-i
 for x in R(W,w):r[0][x]=c()
 for y in R(1,w):r[y][w-1]=c()
 for x in R(1,w):r[w-1][w+~x]=c()
 for x in R(1,w-W):r[w+~x][0]=c()
for l in r:print`l`[2::5]

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

— TFeld
स्रोत
@ Mr.Xcoder .49उस मामले में अभी पर्याप्त पर्याप्त नहीं है , या यह बहुत बड़े इनपुट के लिए विफल है?
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन निश्चित नहीं है, लेकिन यह सुनिश्चित करने के लिए काम करता है, 260 बाइट्स ।
— श्री एक्सकोडर
मैं पायथन को अच्छी तरह से नहीं जानता, लेकिन क्या आपके लिए इनलाइन-चर बनाना संभव है i<j, क्योंकि आप इसे चार बार उपयोग कर रहे हैं?
— केविन क्रूज़सेन
1
245 बाइट्स गोल्फ से +1==1+मेरे पिछले विधि से
— श्री Xcoder
1

पर्ल 5, 177 +2 (-nl) = 179 बाइट्स

2 बाइट्स Xcali के लिए धन्यवाद बचा लिया

sub n{chr 65+$c++%26}@O=(n);while($,++<$_){$_.=$"x$,for@O;push@O,($"x length$O[0])x$,;$O[0]=~s/ /n/eg;s/ $/n/e for@O;1while$O[-1]=~s/.*\K /n/e;s/^ /n/e for reverse@O}print for@O

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

— नहुएल फौलीउल
स्रोत
आप -1इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं $#O। इसके अलावा का उपयोग कर $,के बजाय $nआप अंतरिक्ष से पहले हटाने दूँगी forमें$_.=$"x$n for@O
— Xcali
धन्यवाद, मैं अन्य सुधारों की तलाश में था, लेकिन इस क्षण के लिए नहीं मिला
— नाहुएल फौइउल
बचाए गए 2 और बाइट्स को रेगेक्स s/ (?=\S)/n/eको बदलकरs/.*\K /n/e
— नाहुएल फौइलुल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.