Diberikan array kedalaman apa pun, gambarkan isinya dengan batas di +-|sekitar masing-masing subarray. Itu adalah karakter ASCII untuk plus, minus, dan pipa vertikal.

Misalnya, jika arraynya adalah [1, 2, 3], gambar

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

Untuk array bersarang seperti [[1, 2, 3], [4, 5], [6, 7, 8]], gambar

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

Untuk larik kasar seperti [[[1, 2, 3], [4, 5]], [6, 7, 8]], gambar

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

Perhatikan bahwa ada lebih banyak ruang setelah menggambar [6, 7, 8]. Anda dapat menggambar konten di baris paling atas, tengah, atau paling bawah, tetapi apa pun yang Anda pilih, Anda harus tetap konsisten.

Tantangan ini terinspirasi oleh kata kerja kotak< dari J.

Aturan

• Ini adalah kode-golf sehingga kode terpendek menang.
• Orang bawaan yang memecahkan masalah ini tidak diizinkan.
• Array input hanya akan berisi nilai integer atau array nonnegatif. Setiap array akan homogen, artinya elemen-elemennya akan hanya dengan array atau hanya integer, tetapi tidak pernah campuran keduanya.
• Setiap subarray dapat disarangkan dengan kedalaman apa pun.
• Output dapat berupa string atau array string di mana setiap string adalah garis output.

Uji Kasus

[]
++
||
++

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

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

Terima kasih kepada ngn karena membantu menghapus sekitar sepertiga dari byte.

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

TryAPL

Tentukan fungsi , lalu jalankan setiap test case dan bandingkan dengan ]Displayutilitas bawaan.
[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]]

Penjelasan

Secara keseluruhan, ini adalah fungsi anonim {...}di atas sebuah lampiran ⊂. Yang terakhir hanya menambahkan tingkat lain dari nesting yang mendorong yang pertama untuk menambahkan bingkai luar

Fungsi anonim dengan spasi-putih ( ⋄adalah pemisah pernyataan):

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

Ini dia lagi, tetapi dengan fungsi utilitas yang terpisah:

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

Sekarang saya jelaskan masing-masing fungsi:

CloseBoxmengambil tabel dan mengembalikan tabel yang sama, tetapi dengan kolom pertama tabel ditambahkan di sebelah kanan tabel. Dengan demikian, mengingat tabel 1-by-3 XYZ, fungsi ini mengembalikan tabel 1-by-4 XYZX, sebagai berikut:
 ⊢ argumen (lit. apa yang ada di kanan) yang
 , ditebalkan ke
 ⊣/ kolom paling kiri (lit. reduksi kiri masing-masing baris)

CreateVerticalmengambil sebuah tabel dan mengembalikan sebuah string yang terdiri dari karakter yang cocok |dengan sisi-sisi tabel, tetapi dengan dua +s didahulukan untuk mencocokkan dua baris -. Akhirnya tabel akan diputar satu baris secara siklis untuk mendapatkan satu +---...baris di atas dan di bawah. Dengan demikian, diberikan tiga tabel baris, fungsi ini kembali ++|||, sebagai berikut:
 '++' , dua plus ditambahkan ke
 '|' ⍴⍨ stile yang dibentuk kembali oleh
 ≢ penghitungan argumen (rows ')

AddHorizontalsmengambil daftar-daftar, membuatnya menjadi tabel, menambahkan dua baris -s di atas, menambahkan karakter tepi kiri yang sesuai di sebelah kiri, kemudian memutar satu baris ke bawah, sehingga tabel memiliki batas di atas , kiri, dan bawah. Sebagai berikut:
 1 ⊖ putar satu baris (baris atas ke bawah) dari
 CreateVertical , string yang ++|||...diawali (sebagai kolom) menjadi
 '-' ⍪⍣2 minus yang ditambahkan dua kali ke bagian atas
 ↑ argumen yang diubah dari daftar-daftar ke tabel

{Fungsi anonim }: Jika argumennya adalah daftar sederhana (bukan bersarang), buatlah itu menjadi tabel karakter (dengan demikian, mengingat daftar 3-elemen 1 2 3, fungsi ini mengembalikan tabel karakter 1-oleh-lima karakter yang identik secara visual 1 2 3). Jika argumennya bukan daftar sederhana, pastikan unsur-unsurnya adalah tabel karakter sederhana; pad mereka dengan ketinggian yang sama; bingkai masing-masing di bagian atas, bawah, dan kiri mereka; menggabungkan mereka; dan akhirnya ambil kolom pertama dan tambahkan di sebelah kanan. Sebagai berikut:
 { mulai definisi fungsi anonim
  ⍵ ≡ ∊⍵:jika argumen identik dengan rata argumen (yaitu itu adalah daftar sederhana), maka:
   ⍉ transpos
   ⍪ columnized
   ⍉ dialihkan
   ⍕ ⍵ argumen stringified; lain:
  CloseBox Tambahkan kolom paling kiri di sebelah kanan
  ⊃ ,/
  AddHorizontals¨ add- -on  yang diungkapkan (karena pengurangan tertutup) di- s di atas dan bawah dari masing-masing
  ↓ ↑ ↓¨ padded-to-equal-height * dari
  ∇¨ ⍵  fungsi anonim ini diterapkan pada setiap argumen yang
 } mengakhiri definisi fungsi anonim
* Lit. buat setiap tabel menjadi daftar-daftar, gabungkan daftar-daftar-daftar (padding dengan string kosong untuk mengisi baris pendek) ke dalam tabel, lalu bagi tabel menjadi daftar daftar-daftar-daftar

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

Solusi Port of @ MitchSchwartz Ruby. Versi sebelumnya yang bekerja dengan membungkus array secara rekursif (dan karenanya bekerja untuk konten yang arbitrer, bukan hanya bilangan bulat):

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

Catatan: Meskipun saya menggunakan operator spread dalam daftar argumen saya, untuk mendapatkan output yang diinginkan, berikan parameter tunggal array asli daripada mencoba untuk menyebarkan array; ini memiliki efek membungkus output di kotak luar yang diinginkan. Sayangnya biaya kotak luar saya 18 byte, dan ruang-memisahkan bilangan bulat saya biaya 8 byte, kalau tidak visualisasi alternatif berikut akan cukup untuk 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]

Ruby, 104 byte

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

Fungsi anonim yang mengharapkan string. Misalnya, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}menghasilkan

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

Anda dapat menggunakan kode ini untuk pengujian:

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

Ini dimulai dari baris tengah dan bekerja ke luar. Pertama, contoh }{diganti dengan |. Kemudian, sementara masih ada kurung kurawal, semua {...}string terdalam ditransformasikan ke dalam +-urutan yang sesuai sementara karakter selain |{}diubah menjadi spasi. Pada akhirnya, kawat gigi perantara diubah menjadi pipa.

Brainfuck, 423 byte

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

Diformat dengan beberapa komentar:

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

Cobalah online.

Mengharapkan input diformat seperti (((((4 3 2 1))))(((3 2 1)))((2 1))(1))dengan baris baru yang tertinggal, dan menghasilkan output dari form:

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

Ide dasarnya adalah menghitung karakter mana yang akan dicetak berdasarkan kedalaman sarang. Format output sedemikian rupa sehingga indeks baris batas atas kotak sama dengan kedalaman array yang sesuai, dengan simetri melintasi baris tengah.

Rekaman ini dibagi menjadi 7-sel node, dengan masing-masing node mewakili kolom dalam output.

Loop pertama mengkonsumsi input dan menginisialisasi node, melacak kedalaman dan apakah kolom sesuai dengan tanda kurung (yaitu, apakah kolom berisi perbatasan vertikal), dan mengecilkan kejadian )(menjadi node tunggal.

Loop berikutnya menghasilkan satu baris per iterasi. Di dalam loop ini, loop lain melintasi node dan mencetak satu karakter per iterasi; disinilah sebagian besar pekerjaan dilakukan.

Selama loop inisialisasi, tata letak memori sebuah node pada awal iterasi adalah

x d 0 c 0 0 0

di mana xadalah sebuah boolean flag untuk apakah char sebelumnya adalah kurung penutup, dadalah depth (plus satu), dan cmerupakan karakter saat ini.

Selama loop pencetakan karakter, tata letak memori sebuah simpul di awal iterasi adalah

0 0 d1 d2 c p y

di mana d1menunjukkan kedalaman dibandingkan dengan indeks baris untuk bagian atas; d2mirip dengan d1tetapi untuk bagian bawah; cadalah karakter input untuk kolom itu jika angka atau spasi, jika tidak nol; pmenunjukkan fase, yaitu bagian atas, tengah, atau bawah; dan ymerupakan bendera yang disebarkan dari kiri ke kanan, melacak apakah kita telah mencapai baris tengah. Perhatikan bahwa karena ymenjadi nol setelah memproses sebuah simpul, kita dapat menggunakan ysel dari simpul sebelumnya untuk mendapatkan lebih banyak ruang kerja.

Pengaturan ini memungkinkan kita untuk tidak secara eksplisit menghitung kedalaman maks selama fase inisialisasi; yang ybendera back-disebarkan untuk memperbarui psel-sel sesuai.

Ada -1sel di sebelah kiri node untuk memudahkan navigasi, dan ada sel di sebelah kanan node yang melacak apakah kita telah mencetak baris terakhir.

PHP + HTML, tidak bersaing ( 170 141 135 130 byte)

disimpan 29 byte yang terinspirasi oleh 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>";}

tidak bersaing karena tidak ada keluaran ascii dan karena saya membiarkan browser melakukan semua pekerjaan yang menarik

JavaScript (ES6), 221

Fungsi non rekursif mengembalikan array string (masih menggunakan subfungsi rekursif di dalamnya)

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

Ini berfungsi dalam 2 langkah.

Langkah 1: secara rekursif membangun representasi string dari array input bersarang. Contoh:

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

Odan Ctandai buka dan tutup subarray. Subarrays numerik sederhana dirender dengan elemen yang dipisahkan oleh spasi, sedangkan jika anggota array adalah subarrays mereka dipisahkan oleh koma. String ini terus melacak dari struktur bertingkat dari array input, sementara aku bisa mendapatkan barisan tengah output hanya mengganti OC,dengan |. Sementara secara rekursif membangun string temp ini, saya juga menemukan level kedalaman max dan menginisialisasi array string kosong yang akan berisi bagian atas setengah dari output.
Catatan: kotak luar itu rumit, saya menyarang input di dalam array luar lain, maka saya telah menjatuhkan baris pertama dari output yang tidak diperlukan

Langkah 2: memindai string temp dan membangun output

Sekarang saya memiliki array string kosong, satu untuk setiap level. Saya memindai string temp, melacak level saat ini, yang meningkat untuk masing-masing Odan menurun untuk masing-masing C. Saya memvisualisasikan ini seperti itu:

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

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

Plus yang naik dan turun mengikuti level saat ini

Untuk setiap karakter, saya menambahkan karakter ke setiap baris output, mengikuti aturan:
- jika digit atau spasi, beri tanda '-' di level saat ini dan di bawah, beri spasi di atas
- selain itu, beri tanda '+' di level saat ini, beri tanda '-' jika di bawah dan beri tanda '|' jika di atas

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

Selama pemindaian temp, saya juga membuat baris tengah diganti OC,dengan|

Pada akhir langkah ini, saya memiliki bagian atas dan baris tengah, saya hanya perlu mirror bagian atas untuk mendapatkan bagian bawah dan saya sudah selesai

Lebih sedikit golf, kode komentar

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

)

Uji

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>

Ruby, 245 241 byte

Biaya overhead yang diperlukan untuk membungkus semuanya dalam kotak serta menyelaraskan semuanya cukup berat ...

Output array string, dengan satu string per baris, sesuai spesifikasi. Selaras bawah, bukan pada kasus uji sampel selaras atas karena menghemat 1 byte.

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

Semua solusi bekerja dengan kedalaman maksimum array lebih rendah dari 10. untuk nilai yang lebih besar kedalaman harus disimpan dalam array dan bukan dalam sebuah string.

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

Diperluas

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

untuk 425 Bytes kita bisa membuatnya dengan 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)));

Diperluas

$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 Bytes untuk solusi rekursif

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

Diperluas

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