ฉันคิดว่ามันน่าทึ่งที่ตัวอักษร "H" และ "ฉัน" นั้นมีความคล้ายคลึงกันมาก "H" เป็นจังหวะในแนวนอนที่ล้อมรอบด้วยสองจังหวะในแนวตั้ง "I" เป็นจังหวะในแนวตั้งที่ล้อมรอบด้วยสองจังหวะในแนวนอน (ขึ้นอยู่กับแบบอักษรของคุณ) ฉันพนันได้เลยว่ามันจะซ้อนกัน ... คุณรู้ไหมว่าอะไรทำให้ฉันนึกถึง? เศษส่วน !!!

มานิยามปิรามิด "IHIH" ดังนี้: การวนซ้ำครั้งแรกคือการแสดง ASCII ของตัวอักษร "I":

---
 |
---

การวนซ้ำครั้งถัดไปมีจังหวะตามแนวตั้งที่ด้านใดด้านหนึ่ง

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

หากคุณมองว่า "ฉัน" ที่อยู่ตรงกลางเป็นจังหวะแนวนอนเดียวการทำซ้ำครั้งที่สองนี้โดยทั่วไปจะเป็น "H" การวนซ้ำครั้งที่สามจะเพิ่มการลากเส้นแนวนอนที่ด้านบนและล่าง

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

อีกครั้งถ้าคุณดู "H" ที่อยู่ตรงกลางเป็นจังหวะในแนวดิ่งเดียวการทำซ้ำครั้งนี้จะเป็น "I" รูปแบบนี้ดำเนินต่อไปสลับกันระหว่าง "H" กับ "ฉัน" ทุกครั้ง สำหรับการอ้างอิงต่อไปนี้เป็น 6 การทำซ้ำแรก:

1:
---
 |
---

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

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

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

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

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

ความท้าทาย:

เขียนโปรแกรมหรือฟังก์ชั่นที่ให้ผลลัพธ์การทำซ้ำN'thของปิรามิด IHIH และขึ้นบรรทัดใหม่ที่เป็นทางเลือก ข้อมูลที่คุณป้อนจะเป็นจำนวนเต็มบวกเดียวในรูปแบบที่คุณต้องการ คุณไม่ต้องจัดการอินพุตที่ไม่ถูกต้องเช่นไม่ใช่จำนวนเต็มจำนวนน้อยกว่า 1 เป็นต้นโปรแกรมของคุณจะต้องสร้างเอาต์พุตที่ถูกต้องอย่างน้อยที่สุดสำหรับอินพุตสูงสุดถึง 20 เนื่องจากโค้ดนี้เป็นกอล์ฟกอล์ฟจึงไม่อนุญาตช่องโหว่มาตรฐาน และคำตอบที่สั้นที่สุดเป็นไบต์ชนะ!

Pyth , 50 40 31 25 ไบต์

J @ su เจ + * \ - k + 2lheN + JR * 2; en * \ - KJR "||" + * DK + J * dKQ]] \ | 
LXR "| -") CbjyW% Q2uy + K * \ - + + 2lhG JR * 2; GKQ] \ | 
juCGQuC + K * @ "- |" H + 3yH + JR * 2; GKQ \ |
J @ CBujR * @ "- |" H2CjR * 2; GQ \ |

ชุดทดสอบ

คำอธิบาย

นี่เป็นอัลกอริทึมแบบเรียกซ้ำ

ในการทำซ้ำแต่ละครั้งเราดำเนินการสามอย่าง:

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

Python, 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

ขอบคุณ @DJMcMayhem สำหรับการบันทึก 20 ไบต์ การนำแนวคิดที่อยู่เบื้องหลังคำแนะนำเหล่านั้นไปช่วยประหยัดอีก 12 ไบต์ ขอบคุณ @Maltysen สำหรับข้อเสนอแนะที่ตัดแต่งบางไบต์

ฟังก์ชั่นตั้งค่าตัวคั่นdไปยัง"|"และช่องว่างการแทรกแซงเป็น" "(สำหรับการวนซ้ำเลขคี่), จัดการกับการส่งคืนในกรณีที่เสื่อมโทรมจากนั้นรีเซ็ตตัวคั่นไปที่" "และช่องว่างการแทรกแซงเพื่อ"-"ทำซ้ำเลขคู่ ฟังก์ชันส่งคืนรายการสตริงสำหรับแต่ละบรรทัดของ IHIH โดยฝังผลลัพธ์ของการเรียกซ้ำไปยังฟังก์ชันในตำแหน่งที่ถูกต้องภายในรายการ

Cheddar , 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 ไบต์ที่สั้นกว่าแบบดั้งเดิม

Python 2, 93 ไบต์

Leaky Nun บันทึก 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)

Matricks , 80 62 ไบต์

โซลูชันวนซ้ำ (การเรียกซ้ำใน Matricks นั้นยาก ... )

ทำงานด้วย python matricks.py ihih.txt [[]] <input> --asciiprint

K124; Fiq% 2: วีข [m124: Q * 2 + 3: 1;]; a {Z: Q * 2 + 1;} ;: ข; วี [M45: 1: Q * 2 + 3] ; U {ZQ * 2 + 1:;} ;;: 1: n ;;
K124; Fiq% 2: วีข [m124: Q * 2 + 3: 2;]; B1;: B; วี [M45: 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

JavaScript (ES6), 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อักขระตามด้านบนและล่าง ชุดของตัวละครสามารถสลับการวนซ้ำแต่ละครั้ง แก้ไข: บันทึกไว้ 2 ไบต์โดยกลับเมื่อvn=0

Dyalog APL , 52 43 ไบต์

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

v h s←'|- 'กำหนดอักขระสามตัวให้กับสามชื่อ ( v ertical, h orizontal, s pace)

⊃ อันแรกคือ |

⍪ ทำให้เป็น 1 × 1 ตาราง

{... }⍣⎕รับอินพุตและใช้ฟังก์ชัน braced ที่หลายครั้ง

 v=⊃⍵: ถ้าตัวละครบนซ้ายของการโต้แย้งเป็นแนวตั้งแล้ว:

  h⍪⍨ แนวนอนด้านล่าง

  h⍪ แนวนอนด้านบน

  s, ช่องว่างทางด้านซ้ายของ

  ⍵,s อาร์กิวเมนต์มีช่องว่างทางด้านขวา

 ⋄ อื่น:

  v,⍨ แนวดิ่งไปทางขวาของ

  v, แนวดิ่งไปทางซ้ายของ

  s⍪ ช่องว่างด้านบน

  ⍵⍪s อาร์กิวเมนต์ที่มีช่องว่างด้านล่าง

ลองใช้ออนไลน์!

Brachylogขนาด 84 ไบต์

,[[["|"]]:?:1]i:1:zi:ca~@nw
hh~m["-|":B]:ramggL," "ggS,?:Sz:ca:Srz:caz:Lz:ca:Lrz:ca.

ลองออนไลน์!

พอร์ตของคำตอบของฉันใน Pyth

C, 110 ไบต์

#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]);}

f(n)เรียกว่าเป็น สำหรับ 111 ไบต์ฉันสามารถทำ:

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]);}

คือ#defineบันทึกหนึ่งไบต์

Dyalog APL, 34 ไบต์

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

{... }⍣⍵⍪'|'นำไปใช้ฟังก์ชั่นในการจัดฟัน⍵ครั้งที่เริ่มต้นด้วยเมทริกซ์ 1x1 |ของตัวละคร ผลลัพธ์ของแต่ละแอปพลิเคชันคืออาร์กิวเมนต์สำหรับแอปพลิเคชันถัดไป

s b←' -|'~⊃⍵s is space และ b คือบาร์ที่ไม่ได้อยู่ในมุมบนซ้ายของอาร์กิวเมนต์ ( ' -|'~'-'ลบบาร์แนวนอนออกจากพื้นที่และบาร์แนวตั้ง)

s,⍵,⊃s bเพิ่มพื้นที่ด้านซ้ายและขวา ( ⊃เลือกจากเวกเตอร์ sb)

b,b,⍨⍉ ไขว้และเพิ่ม b ไปทางซ้ายและขวา

สำหรับเลขคี่จะทำให้การย้ายผลลัพธ์ถูกต้องดังนั้นจึงจำเป็นต้องมีการเปลี่ยนรหัสครั้งสุดท้าย

⍉⍣⍵ไขว้⍵ครั้ง (ครั้งเดียวจะเพียงพอ แต่สั้นรหัสวิธีนี้)

TryAPL ออนไลน์

Cheddar , 107 ไบต์

(n,g=n->n?(f->f(f(g(n-1)," ").turn(1),n%2?"-":"|"))((a,b)->a.map(i->b+i+b)):["|"])->(n%2?g(n).turn(1):g(n))

ลองออนไลน์!

Cheddar, 85 ไบต์

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

Cheddar คำตอบแรกของฉัน ลองออนไลน์!

ถ้าฉันพยายามเขียนr=(-n|>n).map(v->abs v).mapแล้วr(y->r(x->…))ล่ามก็ล้มเหลว ; -;

APL (Dyalog Classic) , 34 ไบต์

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

ลองออนไลน์!

(ใช้⎕io←1)

⍳⎕ คือ 1 2 ... N

(⌽,0,⊢) เป็นรถไฟที่เปลี่ยนให้เป็น -N ... -1 0 1 ... N

∘.( )⍨ ดำเนินการวงเล็บสำหรับทุกคู่ของพิกัด ⍺ ⍵

รถไฟ(≤-(1+=)×2|⌈)หรือเทียบเท่า dfn ของมัน{(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}ผลิตเมทริกซ์เช่น:

 ¯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+ ]ทำให้ดัชนีที่ถูกต้องเหล่านี้ใน⎕IO=1และเลือกอักขระที่เกี่ยวข้อง

Ruby, 81 78 77 ไบต์

นี้อยู่บนพื้นฐานของลินน์คำตอบหลาม ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ

แก้ไข: 3 ไบต์ด้วย Lynn การแก้ไขและการเล่นกอล์ฟ 1 ไบต์ต้องขอบคุณจอร์แดน

->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

MATLAB, 168 163 ไบต์

นี่อาจไม่ใช่วิธีที่ฉลาดที่สุดที่จะทำ: การขยายสตริงทุกด้านในnขั้นตอน:

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

การใช้งาน: บันทึกเป็นg.m(ฉันจะต้องเพิ่มที่นับไบต์?) 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

อันที่จริง , 48 45 44 ไบต์

นี่คือความพยายามในการตอบคำถาม Ruby ของฉันไปที่จริง นี่เป็นวิธีที่ยาวเกินไปและข้อเสนอแนะการเล่นกอล์ฟได้รับการชื่นชมอย่างมาก ลองออนไลน์!

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

นี่คือรุ่น 46- ไบต์ซึ่งแยกฟังก์ชันซ้อนกันเพื่อให้เราสามารถกำหนด"| -"จำนวนไบต์ได้น้อยลง ลองออนไลน์!

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

Ungolfing:

ขั้นตอนวิธีแรก

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.

อัลกอริทึมที่สอง

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.

Canvas , 19 18 17 14 ไบต์

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

ลองที่นี่!

หากฉันได้รับอนุญาตให้ส่งออกเอาต์พุตอื่น ๆ ที่หมุนได้ 90 °ตัวอักษร 4 ตัวสุดท้ายสามารถลบออกได้

คำอธิบาย (ตัวละครบางตัวได้รับการเปลี่ยนแปลงเพื่อดู ~ 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°

05AB1E , 29 28 ไบต์

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

ลองออนไลน์!

-1 ขอบคุณ Dzaima ...

นี่เป็นวิธีแก้ซ้ำ

เป็นหลักสิ่งนี้ทำโดยการสร้างรูปแบบต่อไปนี้:

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

จากนั้นให้จับคู่ตามแนวขวางเคลื่อนย้ายองค์ประกอบแต่ละส่วนเข้าด้วยกันและเพิ่มส่วนเสริม

โดยการแปลงหลังการวนซ้ำแต่ละครั้งเราสิ้นสุดการสร้างมุมเดียวของรูปแบบ

จากนั้นเราสามารถใช้คำสั่งการสะท้อนของ 05AB1E

„|-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.

Mathematica, 158 164 ไบต์

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}]

ทางคณิตศาสตร์คำนวณสัญลักษณ์ที่ถูกต้องที่พิกัด (i, j) ซึ่งทั้งคู่วิ่งจาก -n ถึง n รูปแบบของมนุษย์:

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}]

PHP, 166 ไบต์

golfed มากกว่า 100 ไบต์จากวิธีแรกของฉันและยังคงเป็นคำตอบที่ยาวที่สุดที่นี่

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;}

ทำให้พังถล่ม

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;
}

Perl 5 , 150 ไบต์

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

ลองออนไลน์!

Haskell , 110 ไบต์

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

ลองออนไลน์!

คำอธิบาย / Ungolfed

ฟังก์ชั่นตัวช่วยgใช้ตัวละครและรายการของสตริงจากนั้นก่อนและต่อท้ายตัวละครต่อท้ายแต่ละสาย:

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

ถัดไปตัวดำเนินการ(!)ใช้ฟังก์ชัน ( g), ตัวเลข ( n) และอักขระ ( c) จากนั้นคำนวณผลลัพธ์สำหรับn-1ใช้ฟังก์ชันgกับมันและเพิ่มสตริงที่มีความกว้างเดียวกันซึ่งประกอบด้วยcs ถึงจุดเริ่มต้นและสิ้นสุด:

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

ด้วยสิ่งเหล่านี้เราพร้อมที่จะสร้างผลลัพธ์แบบเรียกซ้ำก่อนอื่นเราต้องครอบคลุมกรณีพื้นฐาน:

f 0 = ["|"]

แล้วการสอบถามซ้ำ:

-- 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 ) ' '

J , 37 ไบต์

f=:{&' |-'@*@(-:@=+<-2&|@>.)"{~@:|@i:

TIO

Stax , 22 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

คลายกล่อง ungolfed และแสดงความคิดเห็นมันมีลักษณะเช่นนี้

'|          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

เรียกใช้อันนี้