Data una matrice di qualsiasi profondità, disegna il suo contenuto con bordi +-|attorno a ciascun subarray. Questi sono i caratteri ASCII per il tubo positivo, negativo e verticale.

Ad esempio, se l'array è [1, 2, 3], disegna

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

Per un array nidificato come [[1, 2, 3], [4, 5], [6, 7, 8]], disegnare

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

Per una matrice irregolare come [[[1, 2, 3], [4, 5]], [6, 7, 8]], disegna

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

Si noti che c'è più spazio dopo il disegno [6, 7, 8]. Puoi disegnare i contenuti sulla riga più in alto, al centro o più in basso, ma qualunque cosa tu scelga, devi rimanere coerente.

Questa sfida è stata ispirata dal verbo scatola< di J.

Regole

• Questo è code-golf, quindi vince il codice più corto.
• I builtin che risolvono questo non sono ammessi.
• L'array di input conterrà solo valori interi o array non negativi. Ogni array sarà omogeneo, il che significa che i suoi elementi saranno solo array o solo numeri interi, ma mai un mix di entrambi.
• Ciascun subarray può essere nidificato a qualsiasi profondità.
• L'output può essere una stringa o una matrice di stringhe in cui ogni stringa è una riga di output.

Casi test

[]
++
||
++

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

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

Grazie a ngn per l'aiuto nella rimozione di circa un terzo dei byte.

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

TryAPL

Definire la funzione , quindi eseguire ogni test case e confrontarlo con l' ]Displayutilità integrata .
[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]]

Spiegazione

Nel complesso, questa è una funzione anonima in {...}cima a un allegato ⊂. Quest'ultimo aggiunge semplicemente un altro livello di annidamento che richiede al primo di aggiungere un frame esterno.

La funzione anonima con spazi bianchi ( ⋄è il separatore di istruzioni):

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

Eccolo di nuovo, ma con funzioni di utilità separate:

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

Ora lasciami spiegare ogni funzione:

CloseBoxaccetta una tabella e restituisce la stessa tabella, ma con la prima colonna della tabella aggiunta a destra della tabella. Pertanto, data la tabella 1 per 3 XYZ, questa funzione restituisce la tabella 1 per 4 XYZX, come segue:
 ⊢ l'argomento (lett. Ciò che è a destra)
 , anteposto alla
 ⊣/ colonna più a sinistra (lett. La riduzione sinistra di ciascuno riga)

CreateVerticalprende una tabella e restituisce una stringa composta dai caratteri che si adatterebbero |ai lati della tabella, ma con due +s anteposte a due righe di -. Alla fine la tabella verrà ruotata ciclicamente di una riga per ottenere una +---...riga sopra e sotto. Pertanto, data una tabella a tre righe, questa funzione restituisce ++|||, come segue:
 '++' , due plus anteposti a
 '|' ⍴⍨ uno stile rimodellato dal
 ≢ conteggio (di righe) dell'argomento

AddHorizontalsprende un elenco di elenchi, lo trasforma in una tabella, aggiunge due righe di -s in alto, aggiunge i corrispondenti caratteri del bordo sinistro a sinistra, quindi ruota una riga in basso, in modo che la tabella abbia un bordo in alto , a sinistra e in basso. Come segue:
 1 ⊖ ruota una riga (la riga superiore va in fondo) della
 CreateVertical , stringa ++|||...anteposta (come una colonna) a
 '-' ⍪⍣2 meno aggiunta due volte all'inizio
 ↑ dell'argomento trasformato da elenco di elenchi a tabella

{La funzione anonima }: se l'argomento è un elenco semplice (non nidificato), trasformalo in una tabella di caratteri (quindi, dato l'elenco di 3 elementi 1 2 3, questa funzione restituisce la tabella di caratteri 1 per cinque visivamente identica 1 2 3). Se l'argomento non è un semplice elenco, assicurarsi che gli elementi siano semplici tabelle di caratteri; pad loro alla stessa altezza; inquadrare ciascuno sulla parte superiore, inferiore e sinistra; combinali; e infine prendi la prima colonna e aggiungila a destra. Come segue:
 { iniziare la definizione di una funzione anonima
  ⍵ ≡ ∊⍵:se l'argomento è identico all'argomento appiattito (ovvero è un elenco semplice), quindi:
   ⍉ trasporre l'  argomento
   ⍪ stringificato
   ⍉ trasposto
   ⍕ ⍵colonnato; altro:
  CloseBox aggiungi la colonna più a sinistra a destra di
  ⊃ ,/ la divulgata (perché la riduzione racchiude) concatenata-attraverso
  AddHorizontals¨ aggiunge -s in cima e in fondo a ciascuna
  ↓ ↑ ↓¨ altezza imbottita pari a uguale * di
  ∇¨ ⍵  questa funzione anonima applicata a ciascuno degli argomenti e
 } alla definizione della funzione anonima
* trasforma ogni tabella in un elenco di elenchi, combina gli elenchi di elenchi (riempimento con stringhe vuote per riempire brevi righe) in una tabella, quindi dividi la tabella in un elenco di elenchi di elenchi

JavaScript (ES6), 223 203 byte

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

Porta della soluzione Ruby di @ MitchSchwartz. Versione precedente che funzionava avvolgendo ricorsivamente gli array (e quindi funzionava per contenuti arbitrari, non solo per numeri interi):

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

Nota: anche se sto usando l'operatore spread nel mio elenco di argomenti, per ottenere l'output desiderato, fornisci un singolo parametro dell'array originale invece di provare a diffondere l'array; questo ha l'effetto di avvolgere l'output nella casella esterna desiderata. Purtroppo la scatola esterna mi costa 18 byte e la separazione dello spazio degli interi mi costa 8 byte, altrimenti la seguente visualizzazione alternativa sarebbe sufficiente per 197 byte:

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]

Rubino, 104 byte

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

Funzione anonima che prevede una stringa. Ad esempio, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}produce

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

È possibile utilizzare questo codice per i test:

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

Questo inizia dalla fila centrale e funziona verso l'esterno. Innanzitutto, le istanze di }{vengono sostituite con |. Quindi, mentre ci sono ancora parentesi graffe, tutte le {...}stringhe più interne vengono trasformate nelle +-sequenze appropriate mentre i caratteri diversi da quelli |{}vengono trasformati in spazi. Alla fine, le parentesi graffe intermedie vengono trasformate in tubi.

Brainfuck, 423 byte

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

Formattato con alcuni commenti:

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

Provalo online.

Prevede input formattati come (((((4 3 2 1))))(((3 2 1)))((2 1))(1))con una nuova riga finale e produce output del modulo:

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

L'idea di base è calcolare quale personaggio stampare in base alla profondità della nidificazione. Il formato di output è tale che l'indice di riga del bordo superiore di una casella è uguale alla profondità dell'array corrispondente, con simmetria sulla riga centrale.

Il nastro è diviso in nodi a 7 celle, con ciascun nodo che rappresenta una colonna nell'output.

Il primo ciclo consuma l'input e inizializza i nodi, tenendo traccia della profondità e se la colonna corrisponde a una parentesi (ovvero se la colonna contiene un bordo verticale) e comprime le occorrenze )(in singoli nodi.

Il ciclo successivo genera una riga per iterazione. All'interno di questo ciclo, un altro ciclo attraversa i nodi e stampa un carattere per iterazione; qui è dove si svolge la maggior parte del lavoro.

Durante il ciclo di inizializzazione, il layout di memoria di un nodo all'inizio di un'iterazione è

x d 0 c 0 0 0

dove xè una bandiera booleana per sapere se il carattere precedente era una parentesi chiusa, dè la profondità (più una) ed cè il carattere corrente.

Durante il ciclo di stampa dei caratteri, il layout di memoria di un nodo all'inizio di un'iterazione è

0 0 d1 d2 c p y

dove d1indica la profondità rispetto all'indice di riga per la metà superiore; d2è simile d1ma per la metà inferiore; cè il carattere di input per quella colonna se cifra o spazio, altrimenti zero; pindica la fase, ovvero metà superiore, metà o metà inferiore; ed yè una bandiera che viene propagata da sinistra a destra, tenendo traccia del fatto che abbiamo già raggiunto la fila centrale. Si noti che poiché ydiventa zero dopo l'elaborazione di un nodo, è possibile utilizzare la ycella del nodo precedente per guadagnare più spazio di lavoro.

Questa configurazione ci consente di evitare di calcolare esplicitamente la profondità massima durante la fase di inizializzazione; il yflag viene retro-propagato per aggiornare le pcelle di conseguenza.

C'è una -1cella a sinistra dei nodi per facilitare la navigazione e c'è una cella a destra dei nodi che tiene traccia del fatto che abbiamo ancora stampato l'ultima riga.

PHP + HTML, non in competizione ( 170 141 135 130 byte)

salvato 29 byte ispirati a 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>";}

non competere perché non c'è output ASCII e perché lascio che il browser faccia tutto il lavoro interessante

JavaScript (ES6), 221

Una funzione non ricorsiva che restituisce una matrice di stringhe (utilizzando ancora una funzione secondaria ricorsiva all'interno)

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

Funziona in 2 passaggi.

Passaggio 1: creare ricorsivamente una rappresentazione in formato stringa dell'array di input nidificato. Esempio:

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

Oe Ccontrassegnare il subarray aperto e chiuso. I subarrays numerici semplici sono resi con gli elementi separati da spazio, mentre se i membri dell'array sono subarrays sono separati da virgole. Questa stringa tiene traccia della struttura multilivello dell'array input, mentre posso ottenere la fila centrale dell'uscita semplice sostituzione OC,con |. Mentre costruisco ricorsivamente questa stringa temporanea, trovo anche il livello di profondità massima e inizializzo un array di stringhe vuote che conterrà la metà superiore dell'output.
Nota: la scatola esterna è complicata, annido l'input all'interno di un altro array esterno, quindi ho lasciato cadere la prima riga di output che non è necessaria

Passaggio 2: scansiona la stringa temporanea e crea l'output

Ora ho una serie di stringhe vuote, una per ogni livello. Eseguo la scansione della stringa temporanea, tenendo traccia del livello corrente, che aumenta per ciascuno Oe diminuisce per ciascuno C. Visualizzo questo in questo modo:

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

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

I plus vanno su e giù seguendo il livello attuale

Per ogni carattere, aggiungo un carattere a ogni riga di output, seguendo le regole:
- se cifra o spazio, metti un '-' al livello corrente e sotto, metti uno spazio sopra
- altrimenti, metti un '+' al livello attuale, metti un "-" se sotto e metti un "|" se sopra

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

Durante la scansione temporanea, costruisco anche la riga centrale sostituendola OC,con|

Alla fine di questo passaggio, ho la metà superiore e la riga centrale, devo solo rispecchiare la parte superiore per ottenere la metà inferiore e ho finito

Meno golfed, codice commentato

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

)

Test

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>

Rubino, 245 241 byte

Il sovraccarico necessario per avvolgere tutto in scatole e allineare tutto è piuttosto pesante ...

Emette matrici di stringhe, con una stringa per riga, come da specifica. Allineati in basso anziché i casi di test di esempio allineati in alto perché consente di risparmiare 1 byte.

Provalo online!

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 byte

Tutte le soluzioni funzionano con una profondità massima dell'array inferiore a 10. per valori maggiori, la profondità deve essere archiviata in un array e non in una stringa.

<?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)));

allargato

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

per 425 byte possiamo farlo con 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)));

allargato

$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 byte per una soluzione ricorsiva

<?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)));

allargato

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