Ich finde es faszinierend, wie sehr sich die Buchstaben "H" und "I" ähneln. "H" ist ein horizontaler Strich, der von zwei vertikalen Strichen umgeben ist; "I" ist ein vertikaler Strich, der von zwei horizontalen Strichen umgeben ist (abhängig von Ihrer Schriftart). Ich wette, das könnte verschachtelt sein ... Weißt du, woran mich das erinnert? Fraktale !!!

Definieren wir die "IHIH" -Pyramide wie folgt: Die erste Iteration ist diese ASCII-Darstellung des Buchstabens "I":

---
 |
---

Die nächste Iteration weist auf beiden Seiten einen vertikalen Strich auf.

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

Wenn Sie das "I" in der Mitte als einen einzelnen horizontalen Strich betrachten, ist diese zweite Iteration im Grunde ein "H". Die dritte Iteration fügt oben und unten einen horizontalen Strich hinzu

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

Wenn Sie das "H" in der Mitte als einen einzelnen vertikalen Strich betrachten, ist diese Iteration im Grunde ein "I". Dieses Muster setzt sich fort und wechselt bei jeder Iteration zwischen "H" und "I". Als Referenz sind hier die ersten 6 Iterationen:

1:
---
 |
---

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

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

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

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

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

Die Herausforderung:

Schreiben Sie ein Programm oder eine Funktion, die die N-te Iteration der IHIH-Pyramide und einen optionalen Zeilenumbruch ausgibt. Ihre Eingabe ist eine einzelne positive Ganzzahl in dem von Ihnen gewünschten vernünftigen Format. Sie müssen keine ungültigen Eingaben verarbeiten, z. B. Nicht-Ganzzahlen, Zahlen kleiner als 1 usw. Ihr Programm muss mindestens die richtige Ausgabe für Eingaben bis 20 liefern. Da dies Codegolf ist , sind Standardlücken nicht zulässig und die kürzeste Antwort in Bytes gewinnt!

Pyth , 50 40 31 25 Bytes

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

Testsuite.

Erläuterung

Dies ist ein rekursiver Algorithmus.

In jeder Iteration führen wir drei Aktionen aus:

1. Stellen Sie jeder Zeile ein Leerzeichen voran und fügen Sie es hinzu
2. transponieren Sie das Array
3. prepend und Anfügen zu jeder Zeile entweder "-"oder in "|"Abhängigkeit von der Anzahl der Iteration.

Nach den Iterationen werden die ungeradzahligen Ausgaben transponiert. Deshalb setzen wir sie um.

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 Bytes

Eine rekursive Lösung:

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]

Wird mit aufgerufen print ("\n".join(i(int(sys.argv[1])))), wobei der Parameter die Iterationsnummer der IHIH-Pyramide ist.

Vielen Dank an @DJMcMayhem für die Einsparung von 20 Bytes. Die Idee hinter diesen Vorschlägen weiter zu nehmen, sparte weitere 12 Bytes. Vielen Dank an @Maltysen für Vorschläge, die mehr Bytes gekürzt haben.

Die Funktion setzt das Trennzeichen dauf "|"und die dazwischen liegenden Leerzeichen auf " "(für ungerade Iterationen), behandelt die Rückkehr im entarteten Fall und setzt dann das Trennzeichen auf " "und die dazwischen liegenden Leerzeichen auf "-"für gerade Iterationen zurück. Die Funktion gibt eine Liste von Zeichenfolgen für jede Zeile der IHIH zurück, wobei das Ergebnis eines rekursiven Aufrufs der Funktion an der richtigen Stelle in der Liste eingebettet wurde.

Cheddar , 186 177 165 154 148 131 Bytes

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

Verwendet die Rekursion. Fügt eine Erklärung hinzu, sobald das Golfen abgeschlossen ist.

Probieren Sie es online!

Erläuterung

Dieses ist auch ein bisschen komplex. Behalte alle Variablen im Auge, die ich verwende, aber ich werde versuchen, es einfach zu halten:

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

Dies war eine Herausforderung für den Golfsport, aber seine 55 Bytes sind kürzer als das Original.

Python 2, 93 Bytes

Undichte Nonne sparte 7 Bytes.

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 Bytes

Eine iterative Lösung (Rekursion in Matricks ist schwierig ...)

Laufen Sie mit 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;

Erläuterung:

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

Die rekursive Lösung verwendet die vorherige Iteration, fügt das vZeichen an den Seiten und dann can den Ecken sowie ham oberen und unteren Rand hinzu. Der Zeichensatz wechselt einfach jede Iteration. Bearbeiten: 2 Bytes durch Rückgabe von vwann gespeichert n=0.

Dyalog APL , 52 43 Bytes

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

v h s←'|- 'Abtretungs die drei Zeichen zu drei Namen ( v ertikale, h orizontal, s Tempo)

⊃ der erste, dh |

⍪ Machen Sie in 1 × 1 Tabelle

{... }⍣⎕erhalten Eingaben und wenden die geschweifte Funktion so oft an

 v=⊃⍵: Wenn das linke obere Zeichen des Arguments vertikal ist, gilt Folgendes:

  h⍪⍨ horizontale unten

  h⍪ Horizontale oben

  s, Leerzeichen links von

  ⍵,s das Argument mit Leerzeichen rechts

 ⋄ sonst:

  v,⍨ Vertikale rechts von

  v, Vertikale links von

  s⍪ Leerzeichen darüber

  ⍵⍪s das Argument mit Leerzeichen unten

TryAPL online!

Brachylog , 84 Bytes

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

Probieren Sie es online!

Ein Port meiner Antwort in Pyth .

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

Aufrufen als f(n). Für 111 Bytes könnte ich tun:

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

Dh der #definespeichert genau ein Byte.

Dyalog APL, 34 Bytes

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

{... }⍣⍵⍪'|'Wende die Funktion in geschweiften Klammern an ⍵, beginnend mit 1x1 Zeichenmatrix |. Das Ergebnis jeder Anwendung ist das Argument für die nächste Anwendung.

s b←' -|'~⊃⍵s ist Leerzeichen und b ist der Balken, der sich nicht in der oberen linken Ecke des Arguments befindet. ( ' -|'~'-'Entfernt den horizontalen Balken und lässt Leerzeichen und den vertikalen Balken frei.)

s,⍵,⊃s bfüge links und rechts Leerzeichen hinzu ( ⊃Auswahl s von Vektor sb)

b,b,⍨⍉ transponieren und b nach links und rechts addieren

Bei ungeraden Zahlen bleibt das Ergebnis transponiert, sodass eine endgültige Transponierung erforderlich ist.

⍉⍣⍵Transponierungszeiten ⍵(einmal wäre ausreichend, aber kürzer, um auf diese Weise zu codieren)

TryAPL online

Cheddar , 107 Bytes

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

Probieren Sie es online!

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

Meine erste Antwort von Cheddar. Probieren Sie es online!

Wenn ich versuche zu schreiben r=(-n|>n).map(v->abs v).map, r(y->r(x->…))stürzt der Interpreter ab. ; -;

APL (Dyalog Classic) , 34 Byte

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

Probieren Sie es online!

(verwendet ⎕io←1)

⍳⎕ ist 1 2 ... N

(⌽,0,⊢) ist ein Zug, der daraus macht -N ... -1 0 1 ... N

∘.( )⍨ Führt die Klammern für jedes Koordinatenpaar aus ⍺ ⍵

Der Zug (≤-(1+=)×2|⌈)oder sein dfn-Äquivalent {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}erzeugt eine Matrix wie:

 ¯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+ ]Legt diese gültigen Indizes fest ⎕IO=1und wählt die entsprechenden Zeichen aus

Ruby, 81 78 77 Bytes

Dies basiert auf Lynns Python-Antwort . Golfvorschläge sind willkommen.

Edit: 3 Bytes dank Lynn. Korrekturen und Golfen 1 Byte dank 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 Bytes

Dies ist wahrscheinlich nicht die clevere Methode: Erweitern einer Zeichenfolge nach allen Seiten in nSchritten:

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

Verwendung: Speichern unter g.m(muss ich das zur Byteanzahl hinzufügen?) Und rufen zB auf 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

Eigentlich , 48 45 44 Byte

Dies ist ein Versuch, meine Ruby-Antwort auf Actually zu portieren. Das ist viel zu lang und Golfvorschläge werden sehr geschätzt. Probieren Sie es online!

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

Hier ist eine 46-Byte-Version, die die verschachtelten Funktionen aufteilt, damit wir sie "| -"in weniger Bytes definieren können . Probieren Sie es online!

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

Ungolfing:

Erster Algorithmus

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.

Zweiter Algorithmus

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 Bytes

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

Probieren Sie es hier aus!

Wenn ich jede zweite Ausgabe um 90 ° gedreht ausgeben dürfe, könnten die letzten 4 Zeichen entfernt werden.

Erläuterung (einige Zeichen wurden so geändert, dass sie ~ monospace aussehen):

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

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

Probieren Sie es online!

-1 dank Dzaima ...

Dies ist eine iterative Lösung.

Dies erfolgt im Wesentlichen durch Erstellen des folgenden Musters:

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

Dann paarweise jedes Element zusammen transponieren und die Polsterung hinzufügen.

Durch das Transponieren nach jeder Iteration wird eine einzelne Ecke des Musters erstellt.

Dann können wir die Reflexionsbefehle von 05AB1E verwenden.

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

Berechnet mathematisch das richtige Symbol an den Koordinaten (i, j), wobei beide von -n nach n verlaufen. Menschlich formatiert:

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 Bytes

mehr als 100 Bytes von meinem ersten Ansatz golfen und es ist immer noch die längste Antwort hier.

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

Nervenzusammenbruch

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

Probieren Sie es online!

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

Probieren Sie es online!

Erklärung / Ungolfed

Die gHilfsfunktion nimmt ein Zeichen und eine Liste von Zeichenfolgen entgegen und hängt dieses Zeichen an jede Zeichenfolge an:

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

Als nächstes nimmt der Operator (!)eine Funktion ( g), eine Zahl ( n) und ein Zeichen ( c). Dann berechnet es die Ausgabe für n-1, wendet die Funktion darauf gan und fügt cam Anfang und am Ende eine Zeichenfolge mit der gleichen Breite ein, die aus s besteht:

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

Damit wir die Ausgaben rekursiv generieren können, müssen wir zunächst den Basisfall abdecken:

f 0 = ["|"]

Und dann die Rekursion:

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

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

TIO

Stax , 22 Bytes

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

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus