Tôi thấy thật thú vị khi các chữ cái "H" và "I" rất giống nhau. "H" là một nét ngang được bao quanh bởi hai nét dọc; "Tôi" là một nét dọc được bao quanh bởi hai nét ngang (tùy thuộc vào phông chữ của bạn). Tôi cá rằng điều này có thể được lồng nhau ... Bạn biết điều gì nhắc nhở tôi không? Fractal !!!

Chúng ta hãy định nghĩa kim tự tháp "IHIH" như sau: Lặp lại đầu tiên là biểu diễn ASCII của chữ "I":

---
 |
---

Lặp lại tiếp theo có một nét dọc ở hai bên.

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

Nếu bạn xem "I" ở giữa là một nét ngang đơn lẻ, thì lần lặp thứ hai này về cơ bản là "H". Lặp lại thứ ba thêm một nét ngang ở trên và dưới

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

Một lần nữa, nếu bạn xem "H" ở giữa là một nét dọc đơn, thì lần lặp này về cơ bản là "I". Mô hình này tiếp tục, xen kẽ giữa "H" và "I" trên mỗi lần lặp. Để tham khảo, đây là 6 lần lặp đầu tiên:

1:
---
 |
---

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

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

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

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

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

Các thách thức:

Viết chương trình hoặc hàm tạo ra lần lặp thứ N của kim tự tháp IHIH và một dòng mới tùy chọn. Đầu vào của bạn sẽ là một số nguyên dương duy nhất ở bất kỳ định dạng hợp lý nào bạn muốn. Bạn không phải xử lý các đầu vào không hợp lệ, ví dụ như không phải là số nguyên, số nhỏ hơn 1, v.v. Chương trình của bạn ít nhất phải tạo ra đầu ra phù hợp cho đầu vào tối đa 20. Vì đây là golf-code , các lỗ hổng tiêu chuẩn không được phép và câu trả lời ngắn nhất trong byte thắng!

Bình thường , 50 40 31 25 byte

j @ su, J + * \ - 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 \ |

Bộ thử nghiệm.

Giải trình

Đây là một thuật toán đệ quy.

Trong mỗi lần lặp, chúng tôi thực hiện ba hành động:

1. thêm và nối một khoảng trắng vào mỗi dòng
2. hoán chuyển mảng
3. thêm vào và nối vào mỗi dòng "-"hoặc "|"tùy thuộc vào số lần lặp.

Sau các lần lặp, các đầu ra được đánh số lẻ sẽ được hoán vị. Do đó, chúng tôi hoán chuyển chúng.

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 byte

Một giải pháp đệ quy:

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]

Được gọi với print ("\n".join(i(int(sys.argv[1])))), trong đó tham số là số lần lặp của kim tự tháp IHIH.

Cảm ơn @DJMcMayhem vì đã tiết kiệm 20 byte. Lấy ý tưởng đằng sau những gợi ý đó đã tiết kiệm thêm 12 byte. Cảm ơn @Maltysen vì những gợi ý đã cắt bớt một số byte.

Các bộ chức năng delimiter dđể "|"và không gian can thiệp để " "(ví lặp số lẻ), giao dịch với trở về trong trường hợp thoái hóa, sau đó reset delimiter để " "và không gian can thiệp để "-"cho lặp chẵn. Hàm trả về một danh sách các chuỗi cho mỗi dòng của IHIH, khi đã nhúng kết quả của một cuộc gọi đệ quy đến hàm ở đúng vị trí trong danh sách.

Cheddar , 186 177 165 154 148 131 byte

(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("|")

Sử dụng đệ quy. Sẽ thêm lời giải thích khi chơi golf.

Hãy thử trực tuyến!

Giải trình

Cái này hơi phức tạp quá để theo dõi tất cả các biến tôi đang sử dụng nhưng tôi sẽ cố gắng làm cho nó đơn giản:

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

Đây là một nỗi đau với golf nhưng nó ngắn hơn 55 byte so với ban đầu.

Python 2, 93 byte

Nun rò rỉ đã lưu 7 byte.

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 byte

Một giải pháp lặp lại (Đệ quy trong Matricks là khó ...)

Chạy với python matricks.py ihih.txt [[]] <input> --asciiprint

k124; FiQ% 2: v; b [m124: Q * 2 + 3: 1;]; a {z: Q * 2 + 1;};: b; v [m45: 1: Q * 2 + 3;] ; u {zQ * 2 + 1 :;} ;;: 1: n ;;
k124; FiQ% 2: v; b [m124: Q * 2 + 3: 2;]; B1 ;: b; v [m45: 2: Q * 2 + 3;]; V1 ;;: 1: n ;;

Giải trình:

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 byte

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>

Giải pháp đệ quy hoạt động bằng cách thực hiện lần lặp trước, thêm vký tự sang hai bên, sau đó thêm cký tự vào các góc và hký tự dọc theo đỉnh và đáy. Tập hợp các ký tự chỉ đơn giản xen kẽ mỗi lần lặp. Chỉnh sửa: Đã lưu 2 byte bằng cách quay lại vkhi n=0.

APL Dyalog , 52 43 byte

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

v h s←'|- 'gán ba ký tự cho ba tên ( v vertical, h orizontal, s speed )

⊃ cái đầu tiên, tức là |

⍪ tạo thành bảng 1 × 1

{... }⍣⎕nhận đầu vào và áp dụng chức năng giằng nhiều lần

 v=⊃⍵: nếu ký tự trên cùng bên trái của đối số là dọc, thì:

  h⍪⍨ chiều ngang bên dưới

  h⍪ chiều ngang ở trên

  s, khoảng trắng bên trái của

  ⍵,s đối số có khoảng trắng ở bên phải

 ⋄ khác:

  v,⍨ dọc bên phải của

  v, dọc bên trái của

  s⍪ không gian phía trên

  ⍵⍪s đối số với khoảng trắng bên dưới

Dùng thử trực tuyến!

Brachylog , 84 byte

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

Hãy thử trực tuyến!

Một cổng câu trả lời của tôi trong Pyth .

C, 110 byte

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

Gọi như f(n). Đối với 111 byte, tôi có thể làm:

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

tức là, #definetiết kiệm chính xác một byte.

APL Dyalog, 34 byte

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

{... }⍣⍵⍪'|'Áp dụng chức năng trong ⍵thời gian niềng răng bắt đầu bằng ma trận 1x1 của ký tự |. Kết quả của mỗi ứng dụng là đối số cho ứng dụng tiếp theo.

s b←' -|'~⊃⍵s là không gian và b là thanh không nằm ở góc trên cùng bên trái của đối số ( ' -|'~'-'loại bỏ thanh ngang và để lại không gian và thanh dọc)

s,⍵,⊃s bthêm không gian sang trái và phải ( ⊃chọn s từ vector sb)

b,b,⍨⍉ hoán vị và thêm b sang trái và phải

Đối với các số lẻ, điều này làm cho kết quả được chuyển đổi, do đó, một chuyển vị cuối cùng là bắt buộc.

⍉⍣⍵⍵Thời gian chuyển đổi (một lần sẽ là đủ, nhưng ngắn hơn để mã theo cách này)

Dùng thử trực tuyến

Cheddar , 107 byte

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

Hãy thử trực tuyến!

Cheddar, 85 byte

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

Câu trả lời Cheddar đầu tiên của tôi. Hãy thử trực tuyến!

Nếu tôi cố gắng viết r=(-n|>n).map(v->abs v).map, và sau đó r(y->r(x->…)), trình thông dịch gặp sự cố. ; -;

APL (Dyalog Classic) , 34 byte

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

Hãy thử trực tuyến!

(sử dụng ⎕io←1)

⍳⎕ Là 1 2 ... N

(⌽,0,⊢) là một chuyến tàu biến nó thành -N ... -1 0 1 ... N

∘.( )⍨ thực hiện các dấu ngoặc đơn cho mỗi cặp tọa độ ⍺ ⍵

tàu (≤-(1+=)×2|⌈)hoặc tương đương dfn của nó {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}tạo ra một ma trận như:

 ¯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+ ]làm cho các chỉ số hợp lệ này vào ⎕IO=1và chọn các ký tự tương ứng

Ruby, 81 78 77 byte

Điều này dựa trên câu trả lời Python của Lynn . Gợi ý chơi golf chào mừng.

Chỉnh sửa: 3 byte nhờ Lynn. Sửa chữa và chơi golf 1 byte nhờ 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

MATLAB, 168 163 byte

Đây có lẽ không phải là cách thông minh nhất để làm điều đó: Mở rộng chuỗi trên tất cả các mặt theo ncác bước:

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

Cách sử dụng: Lưu dưới dạng g.m(tôi có phải thêm số đó vào số byte không?) Và gọi vdg(15) .

Ung dung:

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

Trên thực tế , 48 45 44 byte

Đây là một nỗ lực để chuyển câu trả lời Ruby của tôi sang Thực tế. Đây là cách quá dài và đề xuất chơi golf được đánh giá rất cao. Hãy thử trực tuyến!

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

Đây là phiên bản 46 byte phân tách các hàm lồng nhau để chúng ta có thể xác định "| -"trong ít byte hơn. Hãy thử trực tuyến!

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

Ungolfing:

Thuật toán đầu tiên

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.

Thuật toán thứ hai

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 byte

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

Hãy thử nó ở đây!

Nếu tôi được phép xuất mọi đầu ra khác xoay 90 °, 4 ký tự cuối cùng có thể bị xóa.

Giải thích (một số ký tự đã được thay đổi thành 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°

05AB1E , 29 28 byte

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

Hãy thử trực tuyến!

-1 cảm ơn Dzaima ...

Đây là một giải pháp lặp đi lặp lại.

Về cơ bản Điều này được thực hiện bằng cách tạo mẫu sau:

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

Sau đó, ghép đôi, hoán vị từng phần tử với nhau và thêm phần đệm.

Bằng cách hoán vị sau mỗi lần lặp, cuối cùng chúng ta tạo ra một góc duy nhất của mẫu.

Sau đó, chúng ta có thể sử dụng các lệnh phản chiếu của 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.

Toán học, 158 164 byte

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

Về mặt toán học tính toán ký hiệu đúng tại tọa độ (i, j), trong đó cả hai chạy từ -n đến n. Con người định dạng:

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 byte

đánh bại hơn 100 byte trong cách tiếp cận đầu tiên của tôi và nó vẫn là câu trả lời dài nhất ở đây.

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

phá vỡ

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

vô dụng

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 byte

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

Hãy thử trực tuyến!

Haskell , 110 byte

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

Hãy thử trực tuyến!

Giải thích / Ungolfed

Hàm trợ giúp gnhận một ký tự và một danh sách các chuỗi, sau đó nó thêm trước và nối thêm ký tự đó vào mỗi chuỗi:

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

Tiếp theo toán tử (!)lấy một hàm ( g), một số ( n) và một ký tự ( c). Sau đó, nó tính toán đầu ra cho n-1, áp dụng hàm gcho nó và thêm một chuỗi có cùng độ rộng bao gồm cs vào đầu và cuối:

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

Với những điều này, chúng tôi đã sẵn sàng để tạo các kết quả đầu ra theo cách đệ quy, trước tiên chúng tôi cần bao gồm trường hợp cơ sở:

f 0 = ["|"]

Và sau đó là đệ quy:

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

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

TIO

Stax , 22 byte

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

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa, và nhận xét, nó trông như thế này.

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

Chạy cái này