IHIH पिरामिड

34

मुझे यह आकर्षक लगता है कि "H" और "I" अक्षर कैसे समान हैं। "एच" एक क्षैतिज स्ट्रोक है जो दो ऊर्ध्वाधर स्ट्रोक से घिरा हुआ है; "I" एक ऊर्ध्वाधर स्ट्रोक है जो दो क्षैतिज स्ट्रोक (आपके फ़ॉन्ट पर निर्भर करता है) से घिरा हुआ है। मुझे यकीन है कि यह नेस्टेड हो सकता है ... आप जानते हैं कि मुझे क्या याद दिलाता है? भग्न !!!

आइए "IHIH" पिरामिड को निम्नानुसार परिभाषित करें: पहला पुनरावृति यह "I" अक्षर का ASCII प्रतिनिधित्व है:

---
 |
---

अगले पुनरावृत्ति में दोनों तरफ एक ऊर्ध्वाधर स्ट्रोक होता है।

|   |
|---|
| | |
|---|
|   |

यदि आप बीच में "आई" को एक ही क्षैतिज स्ट्रोक के रूप में देखते हैं, तो यह दूसरा पुनरावृत्ति मूल रूप से एक "एच" है। तीसरा पुनरावृति ऊपर और नीचे एक क्षैतिज स्ट्रोक जोड़ता है

-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

फिर, यदि आप बीच में "H" को एक ही ऊर्ध्वाधर स्ट्रोक के रूप में देखते हैं, तो यह पुनरावृत्ति मूल रूप से एक "I" है। यह पैटर्न जारी रहता है, जो हर Heration पर "H" और "I" के बीच होता है। संदर्भ के लिए, यहां पहले 6 पुनरावृत्तियों हैं:

1:
---
 |
---

2:
|   |
|---|
| | |
|---|
|   |

3:
-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

4:
|       |
|-------|
| |   | |
| |---| |
| | | | |
| |---| |
| |   | |
|-------|
|       |

5:
-----------
 |       |
 |-------|
 | |   | |
 | |---| |
 | | | | |
 | |---| |
 | |   | |
 |-------|
 |       |
-----------

6:
|           |
|-----------|
| |       | |
| |-------| |
| | |   | | |
| | |---| | |
| | | | | | |
| | |---| | |
| | |   | | |
| |-------| |
| |       | |
|-----------|
|           |

चुनौती:

एक प्रोग्राम या फ़ंक्शन लिखें जो IHIH पिरामिड के N'th पुनरावृत्ति को आउटपुट करता है , और एक वैकल्पिक अनुगामी न्यूलाइन। आपका इनपुट एक सकारात्मक धनात्मक पूर्णांक होगा जो भी उचित प्रारूप में आप चाहते हैं। आपको अमान्य इनपुट को संभालने की आवश्यकता नहीं है, जैसे गैर-पूर्णांक, संख्या 1 से छोटी, आदि। आपके प्रोग्राम को कम से कम 20 तक के इनपुट के लिए सही आउटपुट का उत्पादन करना होगा। चूंकि यह कोड-गोल्फ है , इसलिए मानक लूपहोल्स की अनुमति नहीं है। और बाइट्स जीत में सबसे छोटा जवाब!

code-golf  ascii-art  fractal 
— DJMcMayhem
स्रोत
क्या यह स्वीकार्य है अगर मैं प्रत्येक पंक्ति में एक-एक तार के तीर लौटाऊं?
— रोहन झुनझुनवाला
चुनौती के मानदंडों को पूरा नहीं किया, लेकिन दुर्घटना से कुछ अच्छा किया ... ऑनलाइन यह कोशिश करो!
— मैजिक ऑक्टोपस Urn

जवाबों:

7

पायथ , 50 40 31 25 बाइट्स

j @ सु, जम्मू + * \ - K + 2lheN + जे आर * 2; en * \ - KJR "||" + * डीके + J * dKQ]] \ | 
LXR "| -") CbjyW% Q2uy + K * \ - + 2lhG + जे आर * 2; GKQ] \ | 
juCGQuC + K * @ "- |" एच + 3yH + जे आर * 2; GKQ \ |
j @ CBujR * @ "- |" H2CjR * 2; जीक्यू \ |

परीक्षण सूट।

व्याख्या

यह एक पुनरावर्ती एल्गोरिदम है।

प्रत्येक पुनरावृत्ति में, हम तीन क्रियाएं करते हैं:

  1. प्रीपेंड करें और प्रत्येक पंक्ति में एक स्थान जोड़ें
  2. सरणी को स्थानांतरित करें
  3. आगे जोड़ते और प्रत्येक पंक्ति या तो करने के लिए संलग्न "-"या "|"यात्रा की संख्या के आधार पर।

पुनरावृत्तियों के बाद, विषम संख्या वाले आउटपुट ट्रांसपोज़ किए जाएंगे। इसलिए, हम उन्हें स्थानांतरित करते हैं।

j@CBujR*@"-|"H2CjR*2;GQ\|   input: Q
j@CBujR*@"-|"H2CjR*2;GQ\|Q  implicit filling of arguments


    u                 Q\|   for Q times, starting with "|", G as current output,
                            H as number of iterations:

                jR*2;G          prepend and append a space to each line
                                (using each line as separator, join [" "," "])
               C                transpose
     jR*      2                 prepend and append the following to each line:
        @"-|"H                      the H-th element of the string "-|" (modular indexing)

 @CB                     Q  select the Q-th element from [output,
                            transposed output] (modular indexing)
j                           join by newlines
— लीक नन
स्रोत
मुझे ट्रांसपोंशन आइडिया बहुत पसंद है।
— टाइटस
12

पायथन, 165 145 133 123 बाइट्स

एक पुनरावर्ती समाधान:

def i(e):
 d="|";a=e*2;x=d+" "*(a-1)+d
 if e<1:return d
 if e%2:d,x=[" ","-"*(a+1)]
 return[x]+[d+z+d for z in i(e-1)]+[x]

के साथ बुलाया गया print ("\n".join(i(int(sys.argv[1])))) , जहां पैरामीटर IHIH पिरामिड की पुनरावृति संख्या है।

20 बाइट बचाने के लिए @DJMcMayhem को धन्यवाद। उन सुझावों के पीछे विचार लेते हुए एक और 12 बाइट्स को बचाया। कुछ और बाइट्स को ट्रिम करने वाले सुझावों के लिए @Maltysen का धन्यवाद।

फ़ंक्शन सीमांकक सेट करता है d को (विषम-विषम पुनरावृत्तियों के लिए) समतल "|"स्थान पर ले जाता है " ", पतित मामले में वापस लौटने से संबंधित होता है, फिर परिसीमन " "और सम-विषम स्थानों को सम-क्रमिक संकेतन के लिए रीसेट करता है "-"। फ़ंक्शन IHIH की प्रत्येक पंक्ति के लिए स्ट्रिंग्स की एक सूची देता है, सूची में सही जगह पर फ़ंक्शन के लिए एक पुनरावर्ती कॉल का परिणाम एम्बेडेड है।

— साइमन
स्रोत
2
अच्छा जवाब, और साइट पर आपका स्वागत है! आपको लाइनों में शामिल होने की आवश्यकता नहीं है, तार की एक सूची ठीक है। कुछ सुझाव: लाइनों को 2 और 3 से बदल दें if e<1:return'|'(उनके बीच कोई नई रेखा नहीं) तो "और" हटा दें और अतिरिक्त इंडेंटेशन को हटा दें।
— DJMcMayhem
1
आप बाद में जगह निकाल सकते हैं return। इसके अलावा, आप ifसेमीकोलन के बिना लाइनों को मर्ज कर सकते हैं , और इंडेंटेशन पर बचा सकते हैं
— माल्टीसेन
1
मैंने आपका उत्तर संपादित कर दिया है। यदि आप उन्हें पसंद नहीं करते हैं, तो कृपया मेरे संपादन को वापस करने के लिए स्वतंत्र महसूस करें।
— लीक नून
10

चेडर , 186 177 165 154 148 131 बाइट्स

(n,b?,c?,q?,g=s->(n-=1)<0?s:g((q=(c=s.lines[0].len)%4>2?b='|'+" "*c+"|":b='-'*(c+2))+"\n"+s.sub(/^|$/gm,q?'|':' ')+"\n"+b))->g("|")

पुनरावृत्ति का उपयोग करता है। एक बार गोल्फिंग करने पर स्पष्टीकरण देंगे।

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

व्याख्या

यह एक थोड़ा जटिल है जो मैं उपयोग कर रहे सभी चर को ट्रैक करता हूं, लेकिन मैं इसे सरल रखने की कोशिश करूंगा:

(
 n,    // Input
 b?,   // Stores row to add to top/bottom
 c?,   // Width of string 
 q?,   // false if I-ifying. true if not
 g=
   s->          // Main logic, s is generated string
    (n-=1)<0 ? s :   // Decrease input each iteration. Stop when 0
    g(               // Recurse with....
      (
        q= (         // Set `q` true if h-ifying. false if I-ifying
         c=s.lines[0].len    // Set `c` to width of string
        ) % 4>2 ?
        b='|'+" "*c+"|" :    // Set `b` to top/bottom row adding
        b='-'*(c+2)          // `*` is repeat, c is from before
      ) + "\n" + 
        s.sub(/^|$/gm,       // Add the following to beginning/end of each line
          q?'|':' '          // if H-ifying, add `|`s if I-ifying add spaces
        ) + "\n" + b         // Add bottom row, generated from before
    )
) -> g("|")     // Middle item is `|`

यह गोल्फ के लिए एक दर्द था लेकिन इसकी 55 बाइट्स मूल से छोटी थीं।

— Downgoat
स्रोत
8

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

लीक नन ने 7 बाइट्स बचाए।

r=range(input()+1)
r=r[:0:-1]+r
for y in r:print''.join('| -'[[x%2,y%2+1][x&-2<y]]for x in r)
— लिन
स्रोत
बंद रूप: ओ: ओ
— लीकी नून
आह, निश्चित रूप से: पहले मुझे इसकी आवश्यकता थी int(x/2.)क्योंकि मैं ले रहा था range(-n,n+1)लेकिन अब मैं बस उन का उपयोग कर सकता हूं। धन्यवाद!
— लिन
मैंने हेडर में Python 2 को निर्दिष्ट किया क्योंकि बस "Python" कहने का अर्थ आमतौर पर Python 2 या Python 3 के तहत कोड काम करता है, जो यहाँ नहीं है।
— मेगो
7

मैट्रिक , 80 62 बाइट्स

एक पुनरावृत्त समाधान (मैट्रिक में पुनरावृत्ति कठिन है ...)

साथ दौड़ो python matricks.py ihih.txt [[]] <input> --asciiprint

k124; Fiq% 2: वी, बी [m124: Q * 2 + 3: 1;]; एक {z: Q * 2 + 1;} ;: ख; वी [एम ​​45: 1: Q * 2 + 3;] ; यू {ZQ * 2 + 1:;} ;;: 1: n ;;
k124; Fiq% 2: वी, बी [m124: Q * 2 + 3: 2;]; बी 1,: ख; वी [एम ​​45: 2: Q * 2 + 3;]; V1 ;;: 1: n ;;

स्पष्टीकरण:

k124;                 # Set the matrix to '|'
F...:1:n;;            # Repeat input times, (Q is iteration variable)
  iQ%2:...:...;       # if statement, check if Q is odd or even
                      # Q is even,
    b;                # Make space to the left
    v[m45:2:Q*2+3;];  # Set the top 2 rows to '-'s
    V1;               # Rotate the matrix up 1 unit, moving the topmost row to the bottom
                      # Q is odd,
    v;                # Make space above
    b[m124:Q*2+3:2;]; # Set the 2 left columns to '|'s
    B1;               # Rotate the matrix left 1 unit, moving the leftmost row to the right
— नीला
स्रोत
1
वाह, पुनरावृत्ति! मैं प्रसन्न हूँ।
— कॉनर ओ'ब्रायन
@ ConorO'Brien Matricks को डायनामिक मैट्रिक्स रिसाइज़िंग के लिए बनाया गया था, इसलिए यह प्रभावशाली नहीं है, लेकिन फिर भी धन्यवाद!
— ब्लू
5

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

f=
(n,[h,c,v]=n&1?`-- `:` ||`)=>n?(c+=h.repeat(n+n-1)+c)+`
${f(n-1).replace(/^|$/gm,v)}
`+c:v
;
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>
स्निपेट का विस्तार करें

पुनरावर्ती समाधान पिछले पुनरावृत्ति को ले कर काम करता है, vचरित्र को पक्षों में जोड़ता है, फिर cकोनों और hशीर्ष और नीचे के साथ चरित्र को जोड़ता है । वर्णों का समूह केवल प्रत्येक पुनरावृति को वैकल्पिक करता है। संपादित करें: vजब लौटकर 2 बाइट्स सहेजे गए n=0।

— नील
स्रोत
4

डायलॉग एपीएल , 52 43 बाइट्स

{v=⊃⍵:h⍪⍨h⍪s,⍵,s⋄v,⍨v,s⍪⍵⍪s}⍣⎕⍪⊃v h s←'|- '

v h s←'|- 'तीन वर्णों को तीन नामों में निर्दिष्ट करता है ( v ertical, h or क्षैतिज, s गति)

⊃ पहला वाला, यानी |

⍪ 1 × 1 तालिका में बनाएं

{... }⍣⎕इनपुट प्राप्त करें और कई बार उस लटके कार्य को लागू करें

 v=⊃⍵: यदि तर्क का शीर्ष-बाएँ वर्ण लंबवत है, तो:

  h⍪⍨ नीचे क्षैतिज

  h⍪ ऊपर क्षैतिज

  s, के बाईं ओर रिक्त स्थान

  ⍵,s सही करने के लिए रिक्त स्थान के साथ तर्क

 ⋄ अन्य:

  v,⍨ के दाईं ओर लंबवत

  v, के बाईं ओर लंबवत

  s⍪ ऊपर रिक्त स्थान

  ⍵⍪s नीचे रिक्त स्थान के साथ तर्क

TryAPL ऑनलाइन!

— एडम
स्रोत
3

C, 110 bytes

#define R(A,B,C)for(A=n,B=1;A<=n;putchar(C),A-=B|=-!A)
f(n,y,x,w,v){R(y,w,10)R(x,v,"| -"[x/2*2<y?y%2+1:x%2]);}

Invoke as f(n). For 111 bytes, I could do:

f(n,y,x,w,v){for(y=n,w=1;y<=n;y-=w|=-!y,puts(""))for(x=n,v=1;x<=n;x-=v|=-!x)putchar("| -"[x/2*2<y?y%2+1:x%2]);}

i.e., the #define saves exactly one byte.

— Lynn
स्रोत
3

Dyalog APL, 34 bytes

{⍉⍣⍵{b,b,⍨⍉s,⍵,⊃s b←' -|'~⊃⍵}⍣⍵⍪'|'}

{...}⍣⍵⍪'|' Apply function in braces ⍵ times starting with 1x1 matrix of character |. The result of each application is the argument for the next application.

s b←' -|'~⊃⍵ s is space and b is the bar not in the top left corner of the argument (' -|'~'-' removes horizontal bar and leaves space and vertical bar)

s,⍵,⊃s b add space to left and right (⊃ picks s from vector s b)

b,b,⍨⍉ transpose and add b to left and right

For odd numbers this leaves the result transposed, so a final transpose is required.

⍉⍣⍵ Transpose ⍵ times (once would be enough, but shorter to code this way)

TryAPL online

— Gil
स्रोत
Welcome to PPCG!
— Stephen
Thanks! Trying to join the party now, lots of fun solving these :)
— Gil
2

Cheddar, 85 bytes

(n,r=(-n|>n).map(v->abs v))->r.map(y->r.map(x->"| -"[(x&-2)<y?y%2+1:x%2]).fuse).vfuse

My first Cheddar answer. Try it online!

If I try to write r=(-n|>n).map(v->abs v).map, and then r(y->r(x->…)), the interpreter crashes. ;-;

— Lynn
स्रोत
You can make v->abs v into (abs) (e.g. r.map((abs))) which will return a function which has the behavior of the abs function. e.g. (+)(1,2) -> 3. (^)(2,6) -> 64. Also big wow on outgolfing me by almost 50%
— Downgoat
No, I tried that: Runtime Error: `abs` has no behavior for types `Number` and `Number` (because map receives both the element and its index, presumably.)
— Lynn
ah :/ i was just about to fix that bug today >_>
— Downgoat
2

APL (Dyalog Classic), 34 bytes

'- |'[2+∘.(≤-(1+=)×2|⌈)⍨(⌽,0,⊢)⍳⎕]

Try it online!

(uses ⎕io←1)

⍳⎕ is 1 2 ... N

(⌽,0,⊢) is a train that turns it into -N ... -1 0 1 ... N

∘.( )⍨ executes the parentheses for every pair of coordinates ⍺ ⍵

the train (≤-(1+=)×2|⌈) or its dfn equivalent {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵} produces a matrix like:

 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
  0  1  0  0  0  0  0  0  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  1  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  0  0  0  0  0  0  1  0
 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

'- |'[2+ ] makes these valid indices in ⎕IO=1 and picks the corresponding characters

— ngn
स्रोत
1

Ruby, 81 78 77 bytes

This is based on Lynn's Python answer. Golfing suggestions welcome.

Edit: 3 bytes thanks to Lynn. Corrections and golfing 1 byte thanks to Jordan.

->n{r=(-n..n).map &:abs;r.map{|y|puts r.map{|x|"| -"[x&-2<y ?y%2+1:x%2]}*""}}

Ungolfing:

def f(n)
  r = -n..n            # Range from -n to n (inclusive)
  r = r.map{|i|i.abs}  # Turns every element of r positive
  r.each do |y|
    s = ""             # a line of the fractal
    r.each do |x|      # build up the fractal based on x and y
      if x/2*2 < y
        s += " -"[y%2]
      else
        s += "| "[x%2]
      end
    end
    puts s             # print the line
  end
end
— Sherlock9
स्रोत
Can you .map(&:abs)?
— Lynn
@Lynn Well spotted. Any other suggestions?
— Sherlock9
The first * isn't doing anything. You can use *"" instead of .join. Also, using p surrounds each line with quotation marks (it calls inspect on its arguments), which might disqualify you.
— Jordan
Also, you can remove the parentheses around &:abs (map &:abs). You might be able to do something with Array#product instead of nested maps, but it'll make line breaks tricky.
— Jordan
@Jordan Your first four hints work, but r.product(r).map (however that works) is longer and does not appear to allow line breaks very easily.
— Sherlock9
1

MATLAB, 168 163 bytes

This is probably not the cleverest way to do it: Expanding a string on all sides in n steps:

function s=g(n);s='|';for m=1:n;if mod(m,2);a=45;b=a;c=0;else a='|';b=0;c=a;end;s=[a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];s(:,end+1)=s(:,1);s(end+1,:)=s(1,:);end

Usage: Save as g.m (do I have to add that to the byte count?) and call e.g. g(15).

Ungolfed:

function s=g(n)

% // Initialize s
s = '|';

for m=1:n
   % // Decide if odd or even number and which symbol to add where
   if mod(m,2)
      a=45;b=a;c=0; % // char(45) is '-' and char(0) is ' ' (thx to Luis Mendo)
   else
      a='|';b=0;c=a;
   end
      % // Add symbols at top and left to s
      s = [a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];
      % // Add symbols at right and bottom to s
      s(:,end+1) = s(:,1);
      s(end+1,:) = s(1,:);
end
— Wauzl
स्रोत
You can replace ' ' by 0 (Matlab treats char 0 as a space) and '-' by 45. File name doesn't have to be included in byte count
— Luis Mendo
1

Actually, 48 45 44 bytes

This is an attempt to port my Ruby answer to Actually. This is way too long and golfing suggestions are very much appreciated. Try it online!

u;±ux♂A╗╜`╝╜";2@%2╛%u╛(2±&<I'-' '|++E"£MΣ.`M

Here is a 46-byte version which separates out the nested functions so that we can define "| -" in fewer bytes. Try it online!

u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£MΣ."%£M

Ungolfing:

First algorithm

u         Increment implicit input.
;±u       Duplicate, negate, increment. Stack: [-n n+1]
x♂A       Range [-n, n+1). Abs(x) over the range.
╗         Save list to register 0. Let's call it res.
╜         Push res so we can iterate over it.
  `         Start function (with y from map() at the end)
  ╝         Save y to register 1.
  ╜         Push res so we can iterate over it.
    "         Start function as string (with x from map() at the end)
    ;         Duplicate x.
    2@%       x mod 2.
    2╛%u      y mod 2 + 1.
    ╛(2±&<I   If x&-2 < y, then y%2+1, else x%2.
    '-' '|++  Push "| -" (We're inside a string right now,
                          so we need to push each char individually)
    E         Grab index of "| -"
    "£        End string and turn into function.
  M         Map over res.
  Σ.        sum() (into a string) and print.
  `         End function.
M         Map over res.

Second algorithm

u;±ux♂A╗╜                  Create res as before.
`;2@%2╛%u╛(2±&<I"| -"E`#   The inner function from the first algorithm put into a list.
                             The only change to the function is the definition of "| -".
"╝╜  £MΣ."                 Most of the outer function from the first algorithm as a string.
   %r      %               %-formats the list into the outer function.
            £M             Turns the string into a function, maps over res.
— Sherlock9
स्रोत
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£M is longer than what you currently have (by 2 bytes), but you might find some inspiration for ways to make it shorter that I'm not seeing.
— Mego
1

Canvas, 19 18 17 14 bytes

|╶［ ｅ↷ｌ|＊ｅ｝╶［↷

Try it here!

If I were allowed to output every other output rotated 90°, the last 4 characters could be removed.

Explanation (some characters have been changed to look ~monospace):

|               push "|" - the canvas
 ╶[       }     repeat input times
    e             encase the canvas in spaces horizontally
     ↷            rotate the canvas 90°
      l|*         push "-" repeated the canvas height times vertically
         e        and encase the canvas if two of those horizontally
           ╶[   repeat input times
             ↷    rotate the canvas 90°
— dzaima
स्रोत
I'd lose 6 bytes if they loosened that restriction too :P.
— Magic Octopus Urn
@MagicOctopusUrn wellp, make that -5 bytes for me :p (could your answer benefit from a transpose loop as well?)
— dzaima
my implementation is a transpose loop :D.
— Magic Octopus Urn
1

05AB1E, 29 28 bytes

„|-S¹>∍ƶćsvy‚˜.Bζ}¹Fζ}»R.∞.∊

Try it online!

-1 thanks to Dzaima...

This is an iterative solution.

Essentially This is made by creating the following pattern:

['|','--','|||',...]

Then, pairwise, transposing each element together and adding the padding.

By transposing after each iteration, we end up creating a single corner of the pattern.

Then, we can use 05AB1E's reflection commands.

„|-S                         # Push ['|','-']
    ¹>∍                      # Extended to input length.
       ƶ                     # Each element multiplied by its index.
        ćs                   # Extract head of list, swap remainder to top.
          v      }           # For each element in the '|-' list...
           y‚˜               # Wrap current 2D array with new entry, flatten.
              .Bζ            # Pad and transpose, leaving it transposed for the next addition.
                 }           # End loop.
                  ¹Fζ}       # Transpose N times.
                      »R     # Bring it all together into a newline string, reverse.
                        .∞.∊ # Mirror horizontally, then vertically with overlap.
— Magic Octopus Urn
स्रोत
0

Mathematica, 158 164 bytes

f[n_]:=Print/@StringJoin/@Map[{{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}}[[##]]&@@#&,Table[{1+i~Mod~2, 1+j~Mod~2, 2+Sign[Abs[i]-Abs[j]]}, {i,-n,n}, {j,-n,n}],{2}]

Mathematically calculates the correct symbol at the coordinates (i,j), where both run from -n to n. Human formatted:

f[n_]:=Print/@
 StringJoin/@
  Map[
   {{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}[[##]]&@@#&,
   Table[{1+i~Mod~2,1+j~Mod~2,2+Sign[Abs[i]-Abs[j]]},{i,-n,n},{j,-n,n}],
   {2}]
— Greg Martin
स्रोत
@Adám Thank you for the pointer to that thread!
— Greg Martin
0

PHP, 166 bytes

golfed more than 100 bytes off my first approach and it´s still the longest answer here.

function i($n){for($m=['|'];$k++<$n;){array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));foreach($m as$i=>&$r)$r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;}return$m;}

breakdown

function h($n)
{
    for($m=['|'];$k++<$n;)
    {
        array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));
        foreach($m as$i=>&$r)
            $r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;
    }
    return$m;
}

ungolfed

function ihih($n)
{
    $m=['|'];                   // iteration 0
    for($k=1;$k<=$n;$k++)       // loop $k from 1 to $n
    {
        $f=$k&1;                        // flag for odd iterations
        // add lines:
        $r=str_repeat(' -'[$f],2*$k-1); // new line: ' ' for even, '-' for odd iterations
        $m[]=$r;                                // append
        array_unshift($m,$r);                   // prepend
        // add columns:
        foreach($m as$i=>&$r)           // for each line
        {
            $c='| '[$f];                        // '|' for even, ' ' for odd iterations
            if($f && (!$i || $i==2*$k)) $c='-'; // '-' in corners for odd iterations
            $r=$c.$r.$c;                        // prepend and append character
        }
    }
    return $m;
}
— Titus
स्रोत
0

Perl 5, 150 bytes

sub h{my$i=pop;my$c=$i%2?$":'|';return(map{"$c$_$c"}h($i-1)),$i%2?'-'x($i*2+1):$c.$"x($i*2-1).$c if$i;()}say for reverse(@q=h<>),$q[0]=~s/---/ | /r,@q

Try it online!

— Xcali
स्रोत
0

Haskell, 110 bytes

f 0=["|"]
f n|odd n=g ' '!n$'-'|1>0=g '|'$id!n$' '
g c=map$(c:).(++[c])
(g!n)c|p<-g.f$n-1=(:p)<>pure$c<$head p

Try it online!

Explanation/Ungolfed

The helper function g takes a character and a list of strings, it then pre- and appends that character to each string:

g c = map (\s-> [c] ++ s ++ [c])

Next the operator (!) takes a function (g), a number (n) and a character (c). It then computes the output for n-1, applies the function g to it and adds a string of the same width consisting of cs to the beginning and end:

(g ! n) c | prev <- g $ f (n-1), ln <- [c | _ <- head p]
          = [ln] ++ prev ++ [ln]

With these we'r ready to generate the outputs recursively, first we need to cover the base case:

f 0 = ["|"]

And then the recursion:

-- for odd n: the previous output needs a space at the end and beginning and then a string of '-' characters at the top and bottom
f n | odd n     = (g ' ' ! n) '-'
-- for even n: the previous output needs a line of spaces at the top and bottom and then each line needs to be enclosed with '|' characters
    | otherwise = g '|' $ (id ! n ) ' '
— ბიმო
स्रोत
0

Stax, 22 bytes

âeò↕\┐▄┤╚╬8φ8Δ☺Pä≤δ₧߃

Run and debug it

Unpacked, ungolfed, and commented, it looks like this.

'|          string literal "|"
{           begin block to repeat
  . |G      push " |", then jump to trailing `}` below 
  '-z2lG    push ["-",[]], then jump to trailing `}` below again
}N          repeat block according to number specified in input
m           output each row in grid

}           goto target - `G` from above jumps to here
  i@        modularly index into pair using iteration index
  ~         push to input stack
  {;|Sm     surround each row with the extracted element
  M         transpose grid

Run this one

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