एक अच्छी तरह से फैला हुआ ASCII सर्पिल

Question

इस सर्पिल पर विचार करें

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

केंद्र में शुरू:

• पहली पंक्ति (ऊपर की ओर) में 3 वर्ण हैं।
• दूसरी पंक्ति में वर्णों की संख्या समान है (3)
• अगला, हम अगले दो पक्षों के लिए दो वर्ण (5) जोड़ते हैं।
• यह पैटर्न जारी रहता है, दो तरफ एक ही लंबाई फिर लंबाई में 2 की वृद्धि।

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

• किसी भी भाषा में लिखें।
• इनपुट / तर्क, आदि आपके सर्पिल में लाइनों की संख्या है।
• प्रत्येक रेखा पिछली पंक्ति के अंत वर्ण से शुरू होती है, जो पिछली पंक्ति की दक्षिणावर्त 90 डिग्री पर होती है।
• मुझे परवाह नहीं है कि व्हॉट्सएप प्रत्येक लाइन के पहले या बाद में है, जब तक कि सर्पिल लाइन के तत्व ऊपर नहीं होते।
• किसी भी गैर-व्हाट्सएप चरित्र के साथ सर्पिल को खींचने के लिए आउटपुट टेक्स्ट।
• छोटी संख्या में बाइट्स में ऐसा करने का प्रयास करें।

परीक्षण के मामले (आउटपुट के रूप में हैश का उपयोग करके):

एन = 1

#
#
#

एन = 2

###
#
#

एन = 3

###
# #
# #
  #
  #

एन = 10

###########
#
# #######
# #     #
# # ### #
# # # # #
# # # # #
# #   # #
# ##### #
#       #
#########

Comments

@ शैगी "आपके द्वारा चुने गए किसी भी गैर-व्हाट्सएप चरित्र के साथ सर्पिल खींचने के लिए आउटपुट टेक्स्ट।" हां, जो भी आपको पसंद हो।

— AJFaraday

संबंधित 1 ; संबंधित २ ।

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

प्रारंभिक छवि के *बजाय है #। अपेक्षित होना?

— वेर्निस्क

@Wernisch यह एक उपयोगी प्रारंभिक बिंदु होने का इरादा था, लेकिन मुझे लगता है कि यह भ्रामक है। आप अपने किसी भी चरित्र का उपयोग कर सकते हैं।

— AJFaraday

Answer 1

05AB1E , 13 11 बाइट्स

कोड:

दो बाइट बचाने के लिए एमिग्ना के लिए धन्यवाद !

LDÈ-Ì'#3Ý·Λ

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

व्याख्या

सर्पिल पर प्रत्येक अलग-अलग किनारे की लंबाई 3 से शुरू होती है और धीरे-धीरे हर दो चरणों में दो से बढ़ जाती है:

$$3, 3, 5, 5, 7, 7, 9,\dots$$

$n$$n$

L                # Create a list from [1 .. input]
 DÈ              # Duplicate and check for each number if even
   -             # Subtract that from the first list
    Ì            # Add 2

यह मूल रूप से हमें लंबाई की वांछित सूची देता है।

     '#          # Push the '#' character
       0246S     # Push the array [0, 2, 4, 6]
            Λ    # Write to canvas

कैनवास एक फ़ंक्शन के रूप में काम करता है जो तीन मापदंडों (जहां सबसे सही पैरामीटर पहले पॉप होता है) को पॉप करता है: <लंबाई (s)> , <char (s)> , <दिशा (s)> । निर्देश पैरामीटर इस मामले में संख्याओं की सूची है। दिशाओं के अनुरूप संख्याएँ हैं:

$$\left[\begin{array}{r} 7 & 0 & 1 \\ 6 & \circ & 2 \\ 5 & 4 & 3 \end{array}\right]$$

इस मामले में, [0, 2, 4, 6] दिशा सूची से मेल खाती है [↑, →, ↓, ←]। कैनवास लंबाई की सूची से प्राप्त प्रत्येक लंबाई पर पुनरावृत्ति करता है, दिशा सूची में '#' वर्ण और चक्रीय रूप से पुनरावृत्त करता है।

Comments

0246S=3Ý·

— एमिगा

@Emigna आह मैंने ऐसा नहीं सोचा था, धन्यवाद!

— अदनान

Answer 2

पायथन 2 , 176 170 165 161 157 बाइट्स

g=lambda a,r:r and g(map(''.join,zip(*a))[::-1],r-1)or a
R=['#']
n=1
exec"R=g(['  '+l for l in g(R,n)][:-1]+[(n+2)*'#'],3*n);n+=1;"*input()
print'\n'.join(R)

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

बार-बार: सर्पिल gके nवें पुनरावृत्ति को 'विहित' स्थिति में घुमाने के लिए उपयोग करता है (एन = 3 या एन = 7 के समान), प्रत्येक मौजूदा पंक्ति के बाईं ओर 2 रिक्त स्थान जोड़कर एक नया खंड जोड़ता है, फिर अंतिम पंक्ति की जगह सभी '#'s के साथ (परिणामस्वरूप N = 4 या N = 8 की तुलना में), और अंत में gफिर से इसे सही स्थिति में घुमाने के लिए उपयोग करना। बल्कि, कुल्ला, दोहराएं।

Answer 3

चारकोल , 16 15 14 बाइट्स

↶ＦＮ«¶×#⁺³⊗÷ι²↷

-2 बाइट्स @Neil की बदौलत ।

इसे ऑनलाइन (क्रिया) आज़माएँ या इसे ऑनलाइन (शुद्ध) आज़माएँ ।

स्पष्टीकरण:

मुद्रण दिशा डिफ़ॉल्ट रूप से दाईं ओर है, और हम ऊपर की ओर शुरू करना चाहते हैं, इसलिए हम 45 डिग्री वामावर्त घुमाकर शुरू करते हैं:

PivotLeft();
↶

फिर iरेंज में लूप [0, input):

For(InputNumber()){ ... }
ＦＮ« ...

एक स्थिति को पीछे ले जाने के प्रभाव की नकल करने के लिए एक नई लाइन प्रिंट करें:

Print("\n");
¶

xवर्तमान दिशा में कई बार "#" राशि प्रिंट करें :

Print(Times("#", ... ));
×# ...

कहां xहै 3 + i // 2 * 2:

Add(3,Doubled(IntegerDivide(i,2))
⁺³⊗÷ι²

और फिर लूप के अगले पुनरावृत्ति के लिए 45 डिग्री दक्षिणावर्त घुमाएँ:

PivotRight();
↷

Comments

मुझे लगता है कि पीछे की ओर बढ़ने के लिए चारकोल में कोई आदेश नहीं है?

— इमीना

@Eignign यकीन नहीं है, लेकिन मैं यह भी नहीं मिल सका। जब मैं यह उत्तर लिख रहा था तब वास्तव में स्वयं को ढूंढ रहा था। एक दिए गए निर्देश के साथ एक चाल है, साथ ही दिए गए निर्देशांक के साथ एक जंप भी है, लेकिन दुर्भाग्य से एक MoveBack नहीं है।

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

⊗÷ι²से एक बाइट कम है ⁻ι﹪ι²। इसके अलावा, आप एस \nसे पहले मुद्रण करके वापस जाने का प्रभाव प्राप्त कर सकते हैं #, जो आपको »#एक अतिरिक्त समग्र बाइट बचत के लिए निकालने की अनुमति देगा ।

— नील

@ नील के लिए धन्यवाद ⊗÷ι², लेकिन एस \nसे पहले मुद्रण के लिए क्या बदलाव होंगे #? अगर मैं जोड़ूं तो सर्पिल गलत हैPrint("\n") ।

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

क्योंकि हथियार अब आपको ओवरलैप करते हैं, उन्हें एक अतिरिक्त #लंबा करने की आवश्यकता है ।

— नील

Answer 4

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

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

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
M=[1,0,-1,0]*n
exec'exec k/2*2*"x+=M[~k];y+=M[k];m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

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

---

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

इस दृष्टिकोण में सूत्रों के लिए उपयोग किया जाता है xऔर yएक देखने सूची के बजाय डेल्टा।

n=input()
S,H=' #'
m=[S*n]*(n%2-~n)
x=n/4*2
y=0--n/4*2
k=2
m[y]=S*x+H+S*n
exec'exec k/2*2*"x+=k%-2+k%4/3*2;y-=(k%2or k%4)-1;m[y]=m[y][:x]+H+m[y][x+1:];";k+=1;'*n
print'\n'.join(m)

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

Comments

n+1+n%2करने n%2-~nके लिए -1 बाइट। और मुझे 0--n/4*21 से छोटा होने के लिए याद रखना चाहिए -(-n/4*2)। मुझसे अच्छा जवाब, +1।

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

Answer 5

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

यकीन है कि यह और अधिक गोल्फ हो सकता है, शायद करी के साथ, लेकिन यहाँ मेरा बहुत विनम्र प्रयास है। पठनीय चरित्र को छोड़कर पठनीयता के लिए लाइन ब्रेक जोड़े गए

r=(a,n=1)=>n?r(a.reduce((_,c)=>c).map((_,i)=>a.map(e=>e[i])).reverse(),n-1):a,
s=n=>n?r(s(n-1)).map((r,i)=>[...r,w,w].map(x=>i?x:'#')):[[w=' ']],
d=n=>r(s(n),1-i).map(r=>r.join``).join`
`

उपयोग: d(10)N = 10 चुनौती उदाहरण के अनुसार एक स्ट्रिंग लौटाता है।

एक समारोह को परिभाषित करता है r(a,n)एक सरणी बारी बारी से करने aसे nबदल जाता है; s(n)2-आयामी सरणी उत्पन्न करने के लिए एक फ़ंक्शन आकार के एक सर्पिल को nपुनरावर्ती रूप से घुमाकर और रिक्ति और रेखाएं जोड़कर उत्पन्न करता है (वापस स्थिति शुरू करने के लिए नहीं घुमाया जाता); और d(n)आकार के एक सर्पिल को खींचने के लिए एक फ़ंक्शन n, चुनौती के अनुसार लगातार घुमाया जाता है, और लौटे स्ट्रिंग के रूप में प्रदान किया जाता है।

यह एक बहुत ही मजेदार चुनौती थी: challenge)