깊이가 배열되면 +-|각 하위 배열 주위에 테두리가있는 내용을 그립니다 . 더하기, 빼기 및 세로 파이프의 ASCII 문자입니다.

예를 들어, 어레이가 있다면 [1, 2, 3], 그릴

+-----+
|1 2 3|
+-----+

같은 중첩 배열 들어 [[1, 2, 3], [4, 5], [6, 7, 8]], 그릴

+-----------------+
|+-----+---+-----+|
||1 2 3|4 5|6 7 8||
|+-----+---+-----+|
+-----------------+

와 같은 거친 배열의 [[[1, 2, 3], [4, 5]], [6, 7, 8]]경우 draw

+-------------------+
|+-----------+-----+|
||+-----+---+|6 7 8||
|||1 2 3|4 5||     ||
||+-----+---+|     ||
|+-----------+-----+|
+-------------------+

그림을 그린 후 더 많은 공간이 있습니다 [6, 7, 8]. 맨 위, 가운데 또는 맨 아래 줄에 내용을 그릴 수 있지만 어느 쪽을 선택하든 일관성을 유지해야합니다.

이 도전은 J 의 박스 동사 <에서 영감을 얻었습니다.

규칙

• 이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.
• 이를 해결하는 내장은 허용되지 않습니다.
• 입력 배열은 음이 아닌 정수 값 또는 배열 만 포함합니다. 각 배열은 동질 적이므로 해당 요소는 배열 만 또는 정수만 사용하지만 둘 다 혼합하지는 않습니다.
• 각 하위 배열은 임의의 깊이로 중첩 될 수 있습니다.
• 출력은 문자열 또는 각 문자열이 출력 라인 인 문자열 배열 일 수 있습니다.

테스트 사례

[]
++
||
++

[[], []]
+---+
|+++|
|||||
|+++|
+---+

[[], [1], [], [2], [], [3], []]
+-----------+
|++-++-++-++|
|||1||2||3|||
|++-++-++-++|
+-----------+

[[[[[0]]]]]
+---------+
|+-------+|
||+-----+||
|||+---+|||
||||+-+||||
|||||0|||||
||||+-+||||
|||+---+|||
||+-----+||
|+-------+|
+---------+

[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+|1||
|||+---------+|||+-----+|||2 1|| ||
||||+-------+|||||3 2 1|||+---+| ||
|||||4 3 2 1|||||+-----+||     | ||
||||+-------+|||+-------+|     | ||
|||+---------+||         |     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

Dyalog APL , 56 바이트

바이트의 약 1/3을 제거하는 데 도움을 주신 ngn에게 감사합니다.

{⍵≡∊⍵:⍉⍪⍉⍕⍵⋄(⊢,⊣/)⊃,/(1⊖('++','|'⍴⍨≢),'-'⍪⍣2↑)¨↓↑↓¨∇¨⍵}⊂

TryAPL

함수를 정의한 다음 각 테스트 케이스를 실행하고 내장 ]Display유틸리티 와 비교하십시오 .
[1, 2, 3]
[[1, 2, 3], [4, 5], [6, 7, 8]]
[[[1, 2, 3], [4, 5]], [6, 7, 8]]
[]
[[], []]
[[], [1], [], [2], [], [3], []]
[[[[[0]]]]]
[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]

설명

전반적으로, 이것은 {...}enclose 상단의 익명 함수 ⊂입니다. 후자는 다른 레벨의 중첩을 추가하여 전자가 외부 프레임을 추가하도록합니다.

공백이있는 익명 함수 ( ⋄문 구분 기호) :

{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    (⊢ , ⊣/) ⊃ ,/ (1 ⊖ ('++' , '|' ⍴⍨ ≢) , '-' ⍪⍣2 ↑)¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

여기 다시 있지만 유틸리티 기능이 분리되어 있습니다.

CloseBox ← ⊢ , ⊣/
CreateVertical ← '++' , '|' ⍴⍨ ≢
AddHorizontals ← 1 ⊖ CreateVertical , '-' ⍪⍣2 ↑
{
    ⍵ ≡ ∊⍵: ⍉ ⍪ ⍉ ⍕ ⍵
    CloseBox ⊃ ,/ AddHorizontals¨ ↓ ↑ ↓¨ ∇¨ ⍵
}

이제 각 기능을 설명하겠습니다.

CloseBox테이블을 가져와 같은 테이블을 반환하지만 테이블의 오른쪽에 테이블의 첫 번째 열이 추가됩니다. 따라서 1x3 테이블 XYZ이 주어지면 이 함수는 XYZX다음과 같이
 ⊢ 1x4 테이블을 반환합니다 .
 , 맨
 ⊣/ 왼쪽 열 앞에 붙은 인수 (lit. 열)

CreateVertical는 테이블을 가져 와서 테이블 |측면에 맞는 문자로 구성 되지만 +의 두 행과 일치하도록 두 개의 접두사가 붙은 문자열을 반환합니다 -. 결국 테이블은 주기적으로 한 행씩 회전하여 +---...위와 아래에 단일 행 을 얻습니다 . 따라서 3 개의 행 테이블이 주어지면이 함수는 ++|||다음과 같이를 반환 합니다.  인수의 (행 ') 탈리로  재구성 된 스타일에
 '++' , 추가 된 2 개의 플러스
 '|' ⍴⍨
 ≢

AddHorizontals리스트리스트를 가져 와서 테이블로 만들고, -맨 위에 두 개의 행을 추가하고, 왼쪽에 해당하는 왼쪽 가장자리 문자를 추가 한 다음 한 행을 맨 아래로 회전하여 테이블에 맨 위에 테두리가 있습니다 , 왼쪽 및 아래쪽. 다음과 같이 : (열로) 앞에 추가  된 문자열
 1 ⊖ 의 한 행 (맨 위 행이 맨 아래로 이동)을  목록의 목록에서 테이블로 변환 된 인수  의 맨 위에 두 번 더한 빼기
 CreateVertical ,++|||...
 '-' ⍪⍣2
 ↑

{익명 함수 }: 인수가 단순 (중첩되지 않은) 목록 인 경우 문자표로 만듭니다 (따라서 3- 요소 목록 1 2 3이있는 경우이 함수는 시각적으로 동일한 1 x 5 문자표를 리턴합니다 1 2 3). 인수가 단순 목록이 아닌 경우 요소가 단순 문자표인지 확인하십시오. 그것들을 같은 높이로 채우십시오. 상단, 하단 및 왼쪽에 각각 프레임; 그것들을 결합하십시오. 마지막으로 첫 번째 열을 가져 와서 오른쪽에 추가하십시오. 다음과 같이 :
 { 익명 함수의 정의를 시작
  ⍵ ≡ ∊⍵:인자는 인자가 평평 동일있을 때 (즉, 그것이 단순 목록)
   ⍉ 전치
   ⍪ columnized
   ⍉ 전치
   ⍕ ⍵ 도 캐릭터 라인 주장; else :
  CloseBox 가장 왼쪽 열을 오른쪽에 추가
  ⊃ ,/ 연접-걸쳐 개시 (환원은 분리 장치 때문)에
  AddHorizontals¨ 추가 -(S)의 각각의 상부 및 하부에서
  ↓ ↑ ↓¨ 의 패딩 투 동일한 높이 *
  ∇¨ ⍵  익명 함수는 인수의 각각에인가
 } 익명 함수의 정의를 종료
문헌 *을 각 테이블을 목록 목록으로 만들고 빈 목록으로 채워진 짧은 목록을 테이블 목록으로 결합한 다음 테이블을 목록 목록으로 분할하십시오.

자바 스크립트 (ES6) 223 203 바이트

f=(a,g=a=>a[0].map?`<${a.map(g).join`|`}>`:a.join` `,s=g([a]),r=[s],t=s.replace(/<[ -9|]*>|[ -9]/g,s=>s[1]?s.replace(/./g,c=>c>`9`?`+`:`-`):` `))=>t<`+`?r.join`\n`.replace(/<|>/g,`|`):f(a,g,t,[t,...r,t])

@MitchSchwartz의 Ruby 솔루션 포트. 이전 버전은 배열을 재귀 적으로 래핑하여 작동하므로 정수가 아닌 임의의 내용에서 작동했습니다.

f=(...a)=>a[0]&&a[0].map?[s=`+${(a=a.map(a=>f(...a))).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[a.join` `]

참고 : 인수 목록에서 스프레드 연산자를 사용하고 있지만 원하는 출력을 얻으려면 배열을 분산시키는 대신 원래 배열의 단일 매개 변수를 제공하십시오. 이것은 원하는 외부 상자에 출력을 감싸는 효과가 있습니다. 안타깝게도 외부 상자의 비용은 18 바이트이고 정수를 공백으로 구분하면 8 바이트의 비용이 듭니다. 그렇지 않으면 197 바이트에 대해 다음 대체 시각화로 충분합니다.

f=a=>a.map?[s=`+${(a=a.map(f)).map(a=>a[0].replace(/./g,`-`)).join`+`}+`,...[...Array(Math.max(0,...a.map(a=>a.length)))].map((_,i)=>`|${a.map(a=>a[i]||a[0].replace(/./g,` `)).join`|`}|`),s]:[``+a]

루비, 104 바이트

->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

문자열을 예상하는 익명 함수 예를 들어, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}생산

+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|         |     | ||
|||+---------+||+-------+|     | ||
||||+-------+||||+-----+||+---+| ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+||||+-----+||+---+| ||
|||+---------+||+-------+|     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

이 코드를 테스트에 사용할 수 있습니다.

f=->s{r=s=s.gsub'}{',?|
r=[s,r,s]*$/while s=s.tr('!-9',' ').gsub!(/{[ |]*}/){$&.tr' -}','-+'}
r.tr'{}',?|}

a=[]

a<<'[1, 2, 3]'
a<<'[[1, 2, 3], [4, 5], [6, 7, 8]]'
a<<'[[[1, 2, 3], [4, 5]], [6, 7, 8]]'
a<<'[]'
a<<'[[], []]'
a<<'[[], [1], [], [2], [], [3], []]'
a<<'[[[[[0]]]]]'
a<<'[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]'

a.map{|s|s.gsub! '], [','}{'
s.tr! '[]','{}'
s.gsub! ',',''
puts s
puts f[s],''}

이것은 가운데 줄에서 시작하여 바깥쪽으로 작동합니다. 먼저의 인스턴스는 }{로 대체됩니다 |. 그런 다음 여전히 중괄호가 있지만 가장 안쪽의 모든 {...}문자열은 적절한 +-시퀀스 로 변환되고 다른 문자 |{}는 공백으로 바뀝니다. 결국 중간 버팀대는 파이프로 바뀝니다.

Brainfuck, 423 바이트

->>+>>,[[>+>+<<-]+++++[>--------<-]>[<+>-[[-]<-]]>[[-]<<[>>>>+<<<<<<-<[>-<-]>>>-
]<<<[-<<<<<<-<]>+>>>]<<<[>>+>>>>>+<<<<<<<-]>>>>>>>>>,]<<+[<<,++>[-[>++<,<+[--<<<
<<<<+]>]]<[-<+]->>>>[<++<<[>>>>>>>+<<<<<<<-]>>>-[<++>-[>>>>+<<<<<++<]<[<<]>]<[>>
+<<<<]>>>+>+>[<<<-<]<[<<]>>>>->+>[-[<-<-[-[<]<[<++<<]>]<[<++++<<]>]<[>+<-[.<<<,<
]<[<<]]>]<[-<<<<<]>>[-[<+>---[<<++>>+[--[-[<+++++++<++>>,]]]]]<+++[<+++++++++++>
-]<-.,>>]>>>>+>>>>]<<-]

일부 주석으로 형식화 됨 :

->>+>>,
[
  [>+>+<<-]
  +++++[>--------<-]
  >
  [
    not open paren
    <+>-
    [
      not paren
      [-]<-
    ]
  ]
  >
  [
    paren
    [-]
    <<
    [
      close paren
      >>>>+<<<<
      <<-<[>-<-]>>>
      -
    ]
    <<<
    [
      open paren directly after close paren
      -<<<<<<-<
    ]
    >+>>>
  ]
  <<<[>>+>>>>>+<<<<<<<-]>>>
  >>>>>>,
]
<<+
[
  <<,++>
  [
    -
    [
      >++<
      ,<+[--<<<<<<<+]
      >
    ]
  ]
  <[-<+]
  ->>>>
  [
    <++<<[>>>>>>>+<<<<<<<-]>>>-
    [
      at or before border
      <++>-
      [
        before border
        >>>>+<<<<
        <++<
      ]
      <[<<]
      >
    ]
    <
    [
      after border
      >>+<<
      <<
    ]
    >>>+>+>
    [
      column with digit or space
      <<<-<
    ]
    <[<<]
    >>>>->+>
    [
      middle or bottom
      -
      [
        bottom
        <-<-
        [
          at or before border
          -
          [
            before border
            <
          ]
          <
          [
            at border
            <++<<
          ]
          >
        ]
        <
        [
          after border
          <++++<<
        ]
        >
      ]
      <
      [
        middle
        >+<
        -[.<<<,<]
        <[<<]
      ]
      >
    ]
    <[-<<<<<]
    >>
    [
      border char or space
      -
      [
        not space
        <+>---
        [
          not plus
          <<++>>
          +
          [
            --
            [
              -
              [
                pipe
                <+++++++<++>>,
              ]
            ]
          ]
        ]
      ]
      <+++[<+++++++++++>-]<-.,>>
    ]
    > >>>+>>>>
  ]
  <<-
]

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

(((((4 3 2 1))))(((3 2 1)))((2 1))(1))후행 줄 바꿈 과 같은 형식의 입력을 예상하고 다음과 같은 형식의 출력을 생성합니다.

+---------------------------------+
|+-------------+---------+-----+-+|
||+-----------+|+-------+|+---+| ||
|||+---------+|||+-----+|||   || ||
||||+-------+|||||     ||||   || ||
|||||4 3 2 1||||||3 2 1||||2 1||1||
||||+-------+|||||     ||||   || ||
|||+---------+|||+-----+|||   || ||
||+-----------+|+-------+|+---+| ||
|+-------------+---------+-----+-+|
+---------------------------------+

기본 아이디어는 중첩 깊이에 따라 인쇄 할 문자를 계산하는 것입니다. 출력 형식은 상자 위쪽 테두리의 행 인덱스가 가운데 행에 대칭으로 해당 배열의 깊이와 같도록하는 것입니다.

테이프는 7 셀 노드로 구분되며 각 노드는 출력의 열을 나타냅니다.

첫 번째 루프는 입력을 사용하고 노드를 초기화하여 깊이를 추적하고 열이 괄호에 해당하는지 (즉, 세로 테두리가 포함되어 있는지 여부) )(단일 노드로 발생하는 항목을 축소합니다 .

다음 루프는 반복 당 하나의 행을 출력합니다. 이 루프 내에서 다른 루프는 노드를 통과하고 반복 당 하나의 문자를 인쇄합니다. 이것은 대부분의 작업이 이루어지는 곳입니다.

초기화 루프 동안 반복 시작시 노드의 메모리 레이아웃은

x d 0 c 0 0 0

여기서 x이전 문자가 닫는 괄호 d인지 깊이에 대한 부울 플래그 (1을 더한 값) 인지 여부 와 c현재 문자입니다.

문자 인쇄 루프 동안 반복 시작시 노드의 메모리 레이아웃은

0 0 d1 d2 c p y

여기서 d1상위 절반에 대한 행 인덱스와 비교 한 깊이를 나타냅니다. 아래쪽 절반 d2과 비슷 d1하지만 절반입니다. c숫자 또는 공백 인 경우 해당 열의 입력 문자입니다. 그렇지 않으면 0입니다. p상, 즉 상반부, 중간 부 또는 하반부를 나타내고; 그리고 y왼쪽에서 오른쪽으로 전파되어 아직 중간 행에 도달했는지 여부를 추적하는 플래그입니다. 이후 참고 y노드를 처리 한 후 제로가, 우리가 사용할 수있는 y더 많은 공간을 작업 얻기 위해 이전 노드의 셀을.

이 설정을 통해 초기화 단계에서 최대 깊이를 명시 적으로 계산하지 않아도됩니다. y플래그를 업데이트 할 수 백 전파 p따라 세포.

가 -1탐색을 용이하게 할 수있는 노드의 왼쪽에있는 셀은, 우리가 아직 마지막 행을 인쇄 여부를 추적 노드의 오른쪽에있는 셀이 있습니다.

경쟁하지 PHP + HTML ( 170 141 135 130 바이트)

SteeveDroz에서 영감을 얻은 29 바이트 저장

<?function p($a){foreach($a as$e)$r.=(is_array($e)?p($e):" $e");return"<b style='border:1px solid;float:left;margin:1px'>$r</b>";}

ascii 출력이 없기 때문에 경쟁하지 않으며 브라우저가 모든 흥미로운 작업을 수행하게했기 때문에

자바 스크립트 (ES6), 221

문자열 배열을 반환하는 비 재귀 함수 (여전히 재귀 하위 함수를 사용하는 경우)

a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

이것은 2 단계로 작동합니다.

1 단계 : 중첩 된 입력 배열의 문자열 표현을 재귀 적으로 빌드합니다. 예:

[[[1, 2, 3], [],[4, 5]], [6, 7, 8]] -> "OOO1 2 3,,4 5C,6 7 8CC"

O및 C개폐 부분 배열을 표시합니다. 간단한 숫자 하위 배열은 요소를 공백으로 구분하여 렌더링하는 반면 배열 멤버가 하위 배열 인 경우 쉼표로 구분됩니다. I 출력 단지 대체 중간 행 얻을 수 있지만이 문자열 입력 어레이의 다중 레벨 구조를 계속 추적 OC,하여이 |. 이 임시 문자열을 재귀 적으로 작성하는 동안 최대 깊이 수준을 찾고 출력의 절반 부분을 포함하는 빈 문자열 배열을 초기화합니다.
참고 : 외부 상자는 까다 롭습니다. 입력을 다른 외부 배열 안에 중첩 한 다음 필요하지 않은 첫 번째 출력 행을 삭제했습니다

2 단계 : 임시 문자열 스캔 및 출력 빌드

이제 각 레벨마다 하나씩 빈 문자열 배열이 있습니다. 나는 현재 수준을 추적하면서 임시 문자열을 스캔하여 각각에 대해 증가하고 각각에 대해 O감소합니다 C. 나는 이것을 이렇게 시각화합니다 :

[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]

OOO1 2 3,,4 5C,6 7 8CC
+                    +
 +            +     +
  +     ++   +
|||1 2 3||4 5||6 7 8||

더하기 위와 아래는 현재 레벨을 따릅니다.

각 문자에 대해 규칙에 따라 모든 출력 행에 문자를 추가합니다
.-숫자 또는 공백 인 경우 현재 레벨 이하에 '-'를 배치하고
그 위에 공백을 배치하십시오. 그렇지 않으면 '+'를 현재 레벨이면 아래에 '-'를 넣고 '|' 위의 경우

OOO1 2 3,,4 5C,6 7 8CC
+--------------------+
|+------------+-----+|
||+-----++---+|     ||
|||1 2 3||4 5||6 7 8||

임시 스캔 중에는 중간 행 OC,을|

이 단계가 끝나면 상단 절반과 가운데 행이 있고 하단 절반을 얻으려면 상단을 미러링하면됩니다.

덜 골프, 주석 코드

a=>{
   r = []; // output array
   R = ( // recursive scan function
     a, // current subarray 
     l  // current level
   ) => (
     r[l] = '', // element of r at level r, init to ""
     a[0] && a[0].map // check if it is a flat (maybe empty) array or an array of arrays
     ? 'O'+a.map(v=>R(v,l+1))+'C' // mark Open and Close, recurse
     : a.join` ` // just put the elements space separated
   );
   T = R([a],-1)]; // build temp string
   // pass the input nested in another array 
   // and start with level -1 , so that the first row of r will not be visible to .map

   // prepare the final output
   m = '' // middle row, built upon the chars in T
   l = -1 // starting level
   [...T].map(c => // scan the temp string
         {
            k = l; // current level
            1/c // check if numeric or space
             ? v = '-- ' // use '-','-',' '
             : (
                 v = '-+|', // use '-','+','|'
                 c > 'C' 
                   ? k=++l // if c=='O', increment level and assign to k
                   : c>'A'&&--l, // if c=='C', decrement level (but k is not changed)
                 c='|' // any of O,C,comma must be mapped to '|'
               );
            m += c; // add to middle row
            r = r.map( (x,i) => // update each output row
                       // based on comparation between row index and level
                       // but in golfed code I don't use the i index
                       // and decrement l at each step  
                       x + v[(k<i)*2+!(k-i)]
                     )
         })
   // almost done!  
   return [...r,m,...r.reverse()]

)

테스트

F=
a=>[...(R=(a,l)=>a[r[l]='',0]&&a[0].map?'O'+a.map(v=>R(v,l+1))+'C':a.join` `)([a],l=-1,r=[],m='')].map(c=>r=r.map(x=>x+v[(k<0)*2+!k--],k=l,1/c?v='-- ':(v='-+|',c>'C'?k=++l:c>','&&--l,c='|'),m+=c))&&[...r,m,...r.reverse()]

out=x=>O.textContent = x+'\n'+O.textContent

;[[1,2,3]
,[[[1, 2, 3], [4, 5]], [6, 7, 8]]
,[]
,[[], []]
,[[], [1], [], [2], [], [3], []]
,[[[[[0]]]]]
,[[[[[4, 3, 2, 1]]]], [[[3, 2, 1]]], [[2, 1]], [1]]
].forEach(t=>
  out(JSON.stringify(t)+'\n'+F(t).join`\n`+'\n')
)  

function update()
{
  var i=eval(I.value)
  out(JSON.stringify(i)+'\n'+F(i).join`\n`+'\n')
}

update()

#I { width:90%}

<input id=I value='[[[1, 2, 3], [],[4, 5]], [6, 7, 8]]' oninput='update()'>
<pre id=O></pre>

루비, 245241 바이트

모든 것을 상자에 포장하고 모든 것을 정렬하는 데 필요한 오버 헤드는 꽤 무겁습니다 ...

스펙에 따라 라인 당 하나의 문자열로 문자열 배열을 출력합니다. 1 바이트를 저장하므로 상단 정렬 샘플 테스트 케이스 대신 하단 정렬.

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

V=->a{a==[*a]?(k=a.map(&V);k[0]==[*k[0]]?[h=?++?-*((k.map!{|z|z[1,0]=[' '*~-z[0].size+?|]*(k.map(&:size).max-z.size);z};f=k.shift.zip(*k).map{|b|?|+b.reduce{|r,e|r+e[1..-1]}+?|})[0].size-2)+?+,*f,h]:[h="+#{?-*(f=k*' ').size}+",?|+f+?|,h]):a}

PHP, 404 바이트

모든 솔루션은 10보다 작은 배열의 최대 깊이에서 작동합니다. 더 큰 값을 얻으려면 심도가 문자열이 아닌 배열에 저장해야합니다.

<?foreach(str_split(json_encode($_GET[a]))as$j){$j!="]"?:$c--;$r=($j==",")?($l=="]"?"":" "):$j;$r=$r=="]"?"|":$r;$r=$r=="["?($v=="]"?"":"|"):$r;if($r!=""){$n.=$r;$d.=+$c;}$v=$l;$l=$j;$j!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

넓히는

foreach(str_split(json_encode($_GET[a]))as$j){ # split JSON representation of the array
    $j!="]"?:$c--;
    $r=($j==",")?($l=="]"?"":" "):$j;
    $r=$r=="]"?"|":$r;
    $r=$r=="["?($v=="]"?"":"|"):$r;
    if($r!=""){
      $n.=$r;  # concanate middle string
      $d.=+$c; # concanate depth position
    }
    $v=$l;
    $l=$j;
    $j!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
# Build the strings before the middle string dependent of value middle string and depth 
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z))); #Output

425 바이트 우리는 이것을 REGEX로 만들 수 있습니다

<?$n=($p=preg_filter)("#\]|\[#","|",$r=$p("#\],\[#","|",$p("#,(\d)#"," $1",json_encode($_GET[a]))));preg_match_all("#.#",$r,$e,256);foreach($e[0] as$f){$f[0]!="]"&&$f[0]!="|"?:$c--;$d.=+$c;$f[0]!="|"&&$f[0]!="["?:$c++;$m>=$c?:$m=$c;}for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

넓히는

$r=preg_filter("#\],\[#","|",preg_filter("#,(\d)#"," $1",json_encode($_GET[a])));
preg_match_all("#.#",$r,$e,256);
$n=preg_filter("#\]|\[#","|",$r); # concanate middle string
foreach($e[0] as$f){
    $f[0]!="]"&&$f[0]!="|"?:$c--;
    $d.=+$c; concanate depth position
    $f[0]!="|"&&$f[0]!="["?:$c++;
    $m>=$c?:$m=$c; # maximum depth of the array
}
# similar to the other ways
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

재귀 솔루션을위한 455 바이트

<?function v($x,$t=0,$l=1){global$d;$d.=$t;$s="|";$c=count($x);foreach($x as$k=>$v){if(is_array($v))$e=v($v,$t+1,$k+1==$c);else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}$s.=$e;}$d.=$l?$t:"";$s.=$l?"|":"";return$s;}$n=v($_GET[a]);$m=max(str_split($d));for($x=0;$x<strlen($n);$x++)for($y=0;$y<$m;$y++)$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));

넓히는

function v($x,$t=0,$l=1){
    global$d; # concanate depth position
    $d.=$t;
    $s="|";
    $c=count($x);
    foreach($x as$k=>$v){           
        if(is_array($v)){$e=v($v,$t+1,$k+1==$c);}
        else{$e=$v." "[$k+1==$c];$d.=str_pad("",strlen($e),$t+1);}
        $s.=$e;
    }
    $d.=$l?$t:"";
    $s.=$l?"|":"";
    return$s;
}
$n=v($_GET[a]); # concanate middle string
$m=max(str_split($d)); # maximum depth of the array
# similar to the other ways 
for($x=0;$x<strlen($n);$x++)
for($y=0;$y<$m;$y++)
$z[$y].=$y==$d[$x]&&$n[$x]=="|"?"+":($y<$d[$x]?"-":($y>$d[$x]&&$n[$x]=="|"?"|":" "));
echo join("\n",$z),"\n$n\n".(join("\n",array_reverse($z)));