Враховуючи масив будь-якої глибини, намалюйте його вміст межею +-|навколо кожного підмасива. Це символи 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]], намалюйте

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

Зауважте, що після малювання залишається більше місця [6, 7, 8]. Ви можете малювати вміст у верхній, центральній або нижній лінії, але що б ви не вибрали, ви повинні залишатися послідовними.

Цей виклик був натхненний бокс дієсловом <від Дж.

Правила

• Це код-гольф, тому найкоротший код виграє.
• Вбудовані, що вирішують це, заборонені.
• Вхідний масив буде містити лише негативні цілі значення чи масиви. Кожен масив буде однорідним, тобто його елементи будуть або лише масивами, або лише цілими числами, але ніколи не будуть поєднанням обох.
• Кожен підмасив може бути вкладений на будь-яку глибину.
• Вихід може бути або у вигляді рядка, або як масив рядків, де кожна рядок є рядком виводу.

Випробування

[]
++
||
++

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

[[], [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|||||+-----+||     | ||
||||+-------+|||+-------+|     | ||
|||+---------+||         |     | ||
||+-----------+|         |     | ||
|+-------------+---------+-----+-+|
+---------------------------------+

Діалог APL , 56 байт

Завдяки ngn за допомогу у видаленні приблизно третини байтів.

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

СпробуйтеAPL

Визначте функцію , потім запустіть кожен тестовий випадок і порівняйте з вбудованою ]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]]

Пояснення

Загалом, це анонімна функція у {...}верхній частині додатка ⊂. Останній просто додає ще один рівень гніздування, що спонукає першого додати зовнішній каркас.

Анонімна функція з пробілом ( ⋄це роздільник висловлювань):

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

Ось знову, але з окремими функціями утиліти:

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

Тепер дозвольте мені пояснити кожну функцію:

CloseBoxбере таблицю і повертає ту саму таблицю, але з першим стовпцем таблиці, доданим праворуч від таблиці. Таким чином, з огляду на таблиця 1 на 3 XYZ, ця функція повертає таблицю 1-на-4 XYZX, наступним чином :
 ⊢ аргумент (букв , що праворуч)
 , передує
 ⊣/ в крайньому лівому стовпчику (букв зліва-редукції кожного рядок)

CreateVerticalбере таблицю і повертає рядок, що складається з символів, які помістилися |s з боків таблиці, але з двома +s попередньо збігалися з двома рядками -. Врешті-решт таблиця буде циклічно повернута на один рядок, щоб отримати один +---...рядок вгорі та внизу. Таким чином, даючи будь-яку таблицю з трьома рядками, ця функція повертається ++|||наступним чином:
 '++' , два плюси, попередньо викладені на
 '|' ⍴⍨ стилі, перетвореному
 ≢ на (рядки) підсумком аргументу

AddHorizontalsприймає список списків, вносить його в таблицю, додає два ряди -s зверху, додає відповідні ліві крайові символи зліва, потім обертає один рядок донизу, щоб у таблиці була межа у верхній частині , зліва та внизу. Таким чином:
 1 ⊖ оберніть один рядок (верхній рядок йде в нижній частині)
 CreateVertical , рядка ++|||..., попередньо попередженого (як стовпець), до
 '-' ⍪⍣2 мінуса, що додається двічі до початку
 ↑ аргументу, перетвореного зі списку списків у таблицю

{Анонімна функція }: Якщо аргумент - це простий (не вкладений) список, введіть його в таблицю символів (таким чином, з урахуванням 3-елементного списку 1 2 3, ця функція повертає візуально ідентичну таблицю символів 1 на п’ять 1 2 3). Якщо аргумент не є простим списком, переконайтеся, що елементи є простими таблицями символів; прокладіть їх на рівну висоту; обрамляйте кожен на верхній, нижній і лівій стороні; поєднувати їх; і нарешті візьміть найперший стовпчик і додайте його праворуч. Як випливає:
 { почати визначення анонімної функції ,
  ⍵ ≡ ∊⍵:якщо аргумент ідентичний сплощеним аргумент (тобто це просто список), а потім:
   ⍉ транспонувати
   ⍪ columnized
   ⍉ транспонованою
   ⍕ ⍵ строкової аргумент; інше:
  CloseBox додайте крайній лівий стовпець праворуч від
  ⊃ ,/ розкрита (оскільки скорочення
  AddHorizontals¨ додається ) з’єднана поперек додавання -s вгорі та внизу кожного з
  ↓ ↑ ↓¨ підкладених на рівну висоту *
  ∇¨ ⍵  цієї анонімної функції, застосованої до кожного з аргументів,
 } закінчує визначення анонімної функції
* Lit. складіть кожну таблицю до списку списків, об'єднайте списки списків (замітка порожніми рядками для заповнення коротких рядків) в таблицю, а потім розділіть таблицю на список списків списків

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

Порт рішення Ruby @ MitchSchwartz Попередня версія, яка працювала шляхом рекурсивного загортання масивів (і тому працювала для довільного вмісту, а не лише цілих чисел):

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 глибина (плюс одна) та чи cє поточний символ.

Під час циклу друку символів розміщується пам'ять вузла на початку ітерації

0 0 d1 d2 c p y

де d1вказується глибина порівняно з індексом рядків для верхньої половини; d2подібний, d1але для нижньої половини; c- символ введення для цього стовпця, якщо цифра або пробіл, інакше нуль; pпозначає фазу, тобто верхню половину, середню або нижню половину; і yце прапор, який розповсюджується зліва направо, відстежуючи, чи досягли ми ще середнього ряду. Зауважте, що зy після обробки вузла стає нульовим, ми можемо використовувати yкомірку попереднього вузла, щоб отримати більше робочого простору.

Ця настройка дозволяє нам уникати явного обчислення максимальної глибини під час фази ініціалізації; тоyпрапор назад-розмножують , щоб оновити pклітини відповідним чином .

-1Ліворуч від вузлів є клітинка для полегшення навігації, а праворуч від вузлів - комірка, яка відстежує, чи ми ще надрукували останній рядок.

PHP + HTML, не конкуруючи ( 170 141 135 130 байт)

збережено 29 байтів, натхненних SteeveDroz

<?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 і тому, що я дозволяю браузеру робити всю цікаву роботу

JavaScript (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позначте відкритий і закритий підмасив. Прості числові підриси відображаються з елементами, розділеними пробілом, тоді як, якщо члени масиву є підрядчиками, вони розділяються комами. Цей рядок відстежує багаторівневу структуру вхідного масиву, в той час як можна отримати середній ряд на виході просто замінити OC,з |. Під час рекурсивної побудови цього рядка temp, я також знаходжу максимальний рівень глибини та ініціалізую масив порожніх рядків, який буде містити половину верхньої частини виводу.
Примітка: зовнішня скринька хитра, я вкладаю вхід у інший зовнішній масив, тоді я викидаю перший рядок виводу, який не потрібен

Крок 2: скануйте тимчасовий рядок і побудуйте висновок

Тепер у мене є масив порожніх рядків, по одному для кожного рівня. Я сканую рядок temp, відстежуючи поточний рівень, який збільшується для кожного 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>

Рубі, 245 241 байт

Накладні витрати, необхідні для загортання всього в коробки, а також вирівнювання всього досить важкі ...

Виводить масиви рядків, по одному рядку на рядок, відповідно до специфікації. Вирівнювання знизу замість вирівнюваних тестових прикладів у верхній частині, оскільки це економить 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)));