문자 "H"와 "I"가 매우 비슷한 점이 매력적입니다. "H"는 두 개의 수직 스트로크로 둘러싸인 수평 스트로크입니다. "I"는 두 개의 수평 스트로크 (글꼴에 따라 다름)로 둘러싸인 수직 스트로크입니다. 나는 이것이 중첩 될 수 내기 ... 내 생각 나게 알아? 프랙탈 !!!

"IHIH"피라미드를 다음과 같이 정의 해 봅시다 : 첫 번째 반복은 문자 "I"의 ASCII 표현입니다.

---
 |
---

다음 반복은 양쪽에 수직 스트로크가 있습니다.

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

가운데의 "I"를 단일 수평 스트로크로 보면이 두 번째 반복은 기본적으로 "H"입니다. 세 번째 반복은 상단과 하단에 수평 스트로크를 추가합니다

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

다시 한 번, 가운데의 "H"를 단일 수직 스트로크로 보면이 반복은 기본적으로 "I"입니다. 이 패턴은 반복 할 때마다 "H"와 "I"가 교대로 계속됩니다. 참고로, 처음 6 개의 반복이 있습니다.

1:
---
 |
---

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

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

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

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

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

도전 과제 :

IHIH 피라미드 의 N 번째 반복 및 선택적인 후행 줄 바꿈 을 출력하는 프로그램 또는 함수를 작성하십시오 . 입력은 원하는 형식으로 된 양의 정수입니다. 유효하지 않은 입력, 예를 들어, 정수가 아닌 숫자, 1보다 작은 숫자 등을 처리 할 필요는 없습니다. 프로그램은 최소한 20 개까지의 입력에 대해 올바른 출력을 생성해야합니다. 이것은 코드 골프 이므로 표준 허점은 허용되지 않습니다 바이트 단위의 최단 답변이 이깁니다!

Pyth , 50 40 31 25 바이트

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

테스트 스위트.

설명

이것은 재귀 알고리즘입니다.

각 반복에서 우리는 세 가지 조치를 수행합니다.

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

파이썬 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의 각 행에 대한 문자열 목록을 리턴하며 목록의 올바른 위치에 함수에 대한 재귀 호출 결과를 임베드했습니다.

체 , 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 바이트는 원본보다 짧습니다.

파이썬 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)

매트릭스 , 80 62 바이트

반복 솔루션 (매트릭스의 재귀는 어렵습니다 ...)

로 실행 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 ;;

설명:

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

자바 스크립트 (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하고 상단 및 하단을 따라 문자를 추가하여 작동합니다 . 문자 집합은 단순히 각 반복을 번갈아 표시합니다. 편집 : vwhen 반환하여 2 바이트를 저장했습니다 n=0.

Dyalog APL , 52 43 바이트

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

v h s←'|- '양수인 세 가지 이름으로 세 개의 문자 ( V의 ertical, 시간 orizontal는 s의 속도)

⊃ 첫 번째 것, 즉 |

⍪ 1 × 1 테이블로 만들다

{... }⍣⎕입력을 받고 여러 번 고정 기능을 적용하십시오.

 v=⊃⍵: 인수의 왼쪽 상단 문자가 수직이면 다음과 같습니다.

  h⍪⍨ 아래 수평

  h⍪ 위의 수평

  s, 왼쪽의 공백

  ⍵,s 오른쪽에 공백이있는 인수

 ⋄ 그밖에:

  v,⍨ 오른쪽의 수직선

  v, 왼쪽의 수직선

  s⍪ 위의 공간

  ⍵⍪s 아래에 공백이있는 인수

TryAPL 온라인!

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정확히 1 바이트를 저장합니다.

Dyalog APL, 34 바이트

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

{... 1x1 문자 행렬로 시작하는 }⍣⍵⍪'|'중괄호로 함수를 적용하십시오.⍵| . 각 응용 프로그램의 결과는 다음 응용 프로그램의 인수입니다.

s b←' -|'~⊃⍵ s는 공백이고 b는 인수의 왼쪽 상단에없는 막대입니다 (' -|'~'-' 가로 막대를 제거하고 공백과 세로 막대를 남깁니다)

s,⍵,⊃s b 왼쪽과 오른쪽에 공백을 추가하십시오 (⊃ 벡터 SB에서 S 선택)

b,b,⍨⍉ 옮김 및 b를 왼쪽과 오른쪽에 추가

홀수의 경우 결과가 바뀝니다. 따라서 최종 바꿈이 필요합니다.

⍉⍣⍵조옮김 ⍵시간

TryAPL 온라인

체다 , 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))

온라인으로 사용해보십시오!

체다, 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

내 첫 체다 답변입니다. 온라인으로 사용해보십시오!

나는 쓰기를 시도하면 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만들고 해당 문자를 선택합니다

루비, 81 78 77 바이트

이것은 Lynn의 Python 답변을 기반으로 합니다. 골프 제안을 환영합니다.

편집 : Lynn 덕분에 3 바이트. 요르단 덕분에 1 바이트 수정 및 골프.

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

풀기 :

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(바이트 수에 추가해야합니까?) eg를 호출하십시오 g(15).

언 골프 드 :

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 바이트

이것은 내 루비 답변을 실제로로 포팅하려는 시도입니다. 이것은 너무 길고 골프 제안은 대단히 감사합니다. 온라인으로 사용해보십시오!

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

"| -"더 적은 바이트로 정의 할 수 있도록 중첩 함수를 분리하는 46 바이트 버전이 있습니다 . 온라인으로 사용해보십시오!

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

풀기 :

첫 번째 알고리즘

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.

캔버스 , 19 18 17 14 바이트

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

여기 사용해보십시오!

90도 회전 한 다른 모든 출력을 출력 할 수 있으면 마지막 4자를 제거 할 수 있습니다.

설명 (일부 문자는 ~ 모노 스페이스로 변경되었습니다) :

|               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.∞.∊

온라인으로 사용해보십시오!

Dzaima 덕분에 -1 ...

이것은 반복적 인 솔루션입니다.

기본적으로 이것은 다음 패턴을 작성하여 이루어집니다.

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

그런 다음, 쌍을 이루어 각 요소를 서로 바꾸고 패딩을 추가합니다.

각 반복 후에 조옮김으로써 패턴의 단일 코너를 만듭니다.

그런 다음 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.

매쓰, 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 바이트

첫 번째 접근 방식에서 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;
}

언 골프

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

펄 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

온라인으로 사용해보십시오!

하스켈 , 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

온라인으로 사용해보십시오!

설명 / 비 골프

도우미 함수 g는 문자와 문자열 목록을 가져 와서 각 문자에 해당 문자를 미리 추가합니다.

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

다음으로 연산자 (!)는 함수 ( g), 숫자 ( n) 및 문자 ( c)를 사용합니다. 그런 다음에 대한 출력을 계산하고 n-1함수 g를 적용 c하고 시작과 끝에 s 로 구성된 동일한 너비의 문자열을 추가합니다 .

(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ä≤δ₧߃

실행 및 디버깅

포장을 풀고 포장을 풀고 주석을 달았습니다.

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

이것을 실행