Herhangi bir derinlikte bir dizi göz önüne alındığında, içeriğini +-|her bir alt dizinin sınırlarıyla çizin . Bunlar artı, eksi ve dikey borular için ASCII karakterleridir.

Örneğin, dizi ise [1, 2, 3], çizmek

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

Gibi iç içe geçmiş bir dizide için [[1, 2, 3], [4, 5], [6, 7, 8]], çizmek

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

Gibi düzensiz bir dizi için [[[1, 2, 3], [4, 5]], [6, 7, 8]]çizmek

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

Çizimden sonra daha fazla alan olduğuna dikkat edin [6, 7, 8]. İçeriği en üst, orta veya en alt satırda çizebilirsiniz, ancak hangisini seçerseniz, tutarlı kalmalısınız.

Bu meydan okuma J kutusundaki fiilden esinlenmiştir.<

kurallar

• Bu kod golf yani en kısa kod kazanır.
• Bunu çözen yerleşiklere izin verilmez.
• Giriş dizisi yalnızca negatif olmayan tamsayı değerleri veya dizileri içerecektir. Her bir dizi homojen olacaktır, yani elementleri sadece dizilerle veya sadece tamsayılarla değil, her ikisinin karışımından oluşmaz.
• Her alt dizi herhangi bir derinliğe yuvalanabilir.
• Çıktı, bir dize olarak veya her dizenin bir çıktı satırı olduğu bir dize dizisi olarak olabilir.

Test Kılıfları

[]
++
||
++

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

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

Baytların yaklaşık üçte birinin kaldırılmasına yardımcı olduğu için teşekkür ederiz.

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

TryAPL

İşlevi tanımlayın , sonra her test çalışmasını çalıştırın ve yerleşik ]Displayyardımcı programla karşılaştırın.
[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]]

açıklama

Genel olarak, bu {...}bir enclose üstünde anonim bir işlevdir ⊂. İkincisi, birincisine dış çerçeve eklemesini isteyen başka bir yerleştirme düzeyi ekler.

Boşluklu anonim işlev ( ⋄deyim ayırıcı):

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

İşte yine, ancak ayrılmış yardımcı program işlevleriyle:

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

Şimdi her bir işlevi açıklayayım:

CloseBoxbir tablo alır ve aynı tabloyu döndürür, ancak tablonun sağına eklenmiş tablonun ilk sütunu bulunur. Bu durumda, 1-by-3 tablosu verilmiştir XYZ, bu fonksiyon 1-4 ile masa döner XYZXolarak, aşağıdaki gibidir:
 ⊢ bağımsız değişken (sağda olanı lit.)
 , başına ilave
 ⊣/ sol sütununda (her biri sol indirgeme aydınlatılmış kürek çekmek)

CreateVerticalbir tablo alır ve tablonun |kenarlarına sığacak karakterlerden oluşan bir dize döndürür , ancak ikisi +iki sırayla eşleşmeye hazırdır -. Sonunda masa, bir +---...satırın üstünde ve altında bir satır almak için döngüsel olarak bir satır döndürülür . Böylece, herhangi bir üç  satırlık tablo verildiğinde, bu işlev ++|||aşağıdaki gibi döner : argümanın (satırlar) tamiratı  tarafından yeniden şekillendirilmiş bir stile
 '++' , önceden hazırlanmış iki artı
 '|' ⍴⍨
 ≢

AddHorizontalslistelerin bir listesini alır, tabloya sokar -, üstüne iki sıra ekler, karşılık gelen sol kenar karakterlerini sola ekler, sonra tablonun üst kısmında bir kenarlık olacak şekilde bir sıra döndürür , sol ve alt. Aşağıdaki gibi: Listelenen  listeden tabloya dönüştürülen bağımsız değişkenin  iki katına eklenmiş olarak eklenmiş  dizginin (bir sütun olarak) dizenin
 1 ⊖ bir satırını (en üst satırın altına iner) döndürün
 CreateVertical ,++|||...
 '-' ⍪⍣2
 ↑

{Anonim işlev }: Eğer argüman basit (iç içe geçmemiş) bir liste ise, karakter tablosuna dönüştürün (3 eleman listesi verildiğinde 1 2 3, bu işlev görsel olarak 1'e 5 karakter tablosunu döndürür 1 2 3). Bağımsız değişken basit bir liste değilse, öğelerin basit karakter tabloları olduğundan emin olun; onları eşit yüksekliğe kadar doldurun; her birini üst, alt ve solda çerçevele; onları birleştirmek; ve son olarak ilk sütunu alın ve sağa ekleyin. Olarak aşağıdaki gibidir:
 { isimsiz bir işlev tanımını başlar
  ⍵ ≡ ∊⍵:bağımsız değişken bağımsız değişken düzleştirilmiş ile aynı ise, daha sonra (örneğin, basit bir liste değildir):
   ⍉ devrik
   ⍪ columnized
   ⍉ transpoze
   ⍕ ⍵ dizgelenmiş bağımsız değişken; else:
  CloseBox En sağdaki sütunu sağına ekle
  ⊃ ,/ açıklanan (redüksiyon mahfazaları) bir araya   getirilmişse, argümanların her birine uygulanan bu adsız fonksiyonun her birinin üzerine ve altına her biri üzerine adlandırmalar
  AddHorizontals¨ eklenir  * adsız fonksiyonun  tanımını bitirir * Lit. Her tabloyu bir liste listesine sokun, liste listelerini (kısa satırları doldurmak için boş dizelerle doldurun) bir tabloya birleştirin, sonra tabloyu liste listeleri listesine ayırın-
  ↓ ↑ ↓¨
  ∇¨ ⍵
 }

JavaScript (ES6), 223 203 bayt

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'ın Ruby çözümünün limanı. Dizileri yinelemeli olarak sarmakla çalışan önceki sürüm (ve bu nedenle yalnızca tamsayılar yerine keyfi içerik için çalışıyordu):

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

Not: Argüman listemde spread operatörünü kullanmama rağmen, istenen çıktıyı elde etmek için diziyi yaymaya çalışmak yerine orijinal dizinin tek bir parametresini sağlayın; Bu, çıktının istenen dış kutuya sarılması etkisine sahiptir. Maalesef dış kutu bana 18 bayta mal oluyor ve tamsayıları ayırmak bana 8 bayta mal oluyor, aksi takdirde aşağıdaki alternatif görselleştirme 197 bayt için yeterli olacaktır:

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 bayt

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

Bir dize bekleyen anonim işlev. Örneğin, {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}üretir

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

Bu kodu test için kullanabilirsiniz:

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

Bu orta sıradan başlar ve dışarı doğru çalışır. İlk olarak, örnekleri }{ile değiştirilir |. Daha sonra, hala kaşlı ayraçlar varken, en içteki tüm {...}dizeler, boşluktan +-başka karakterlere dönüştürülürken uygun dizilere |{}dönüştürülür. Sonunda, ara parantez borulara dönüştürülür.

Brainfuck, 423 bayt

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

Bazı yorumlar ile biçimlendirilmiş:

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

Çevrimiçi deneyin.

(((((4 3 2 1))))(((3 2 1)))((2 1))(1))Sondaki yeni satırda olduğu gibi biçimlendirilmiş girdiyi bekler ve formun çıktısını üretir:

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

Temel fikir, iç içe geçme derinliğine göre hangi karakterin yazdırılacağını hesaplamaktır. Çıktı formatı, bir kutunun üst sınırının satır endeksinin, orta sıra boyunca simetri ile karşılık gelen dizinin derinliğine eşit olacağı şekildedir.

Bant 7 hücreli bölümlere ayrılmıştır, her düğüm çıkışta bir sütunu temsil eder.

İlk döngü girdiyi tüketir ve düğümleri başlatır, derinliği takip eder ve sütunun paranteze karşılık gelip gelmediğini (yani, sütunun dikey kenarlık içerip içermediğini) ve )(tek düğümlerin çöküşlerini gösterir.

Bir sonraki döngü her yineleme için bir satır çıkar. Bu döngü içinde, başka bir döngü düğümleri dolaşır ve yineleme başına bir karakter basar; Burası işlerin çoğunun gerçekleştiği yer.

Başlatma döngüsü sırasında, bir yinelemenin başlangıcındaki bir düğümün bellek düzeni

x d 0 c 0 0 0

burada xönceki karakter bir kapatma parantez olup olmadığı için bir Boole bayrağıdır, dderinlik (artı bir), ve cmevcut bir karakterdir.

Karakter yazdırma döngüsü sırasında, bir yinelemenin başlangıcındaki bir düğümün bellek düzeni

0 0 d1 d2 c p y

burada d1ilk yarı için sıra indeksine kıyasla derinliği gösterir; d2benzer d1ancak alt yarı için; cbasamak veya boşluk varsa o sütunun giriş karakteri, aksi halde sıfır; pfazı, yani üst yarı, orta veya alt yarıyı belirtir; ve ysoldan sağa doğru yayılan, henüz orta sıraya ulaşıp ulaşmadığımızı takip eden bir bayrak. Çünkü unutmayın ybir düğümü işledikten sonra sıfır olur, biz kullanabilirsiniz ydaha çalışma alanı kazanmak için önceki düğümün hücreyi.

Bu kurulum, başlatma aşaması sırasında maksimum derinliği açıkça hesaplamaktan kaçınmamızı sağlar; ybayrağı güncellemek için geri-yayılır pbuna göre hücre.

Bir yoktur -1dolaşımını kolaylaştırmak amacıyla düğümlerin solundaki hücre ve biz henüz son satırı baskılı olup olmadığını izler düğümlerin sağına bir hücre vardır.

PHP + HTML, rekabet etmiyor ( 170 141 135 130 bayt)

29 bayt SteeveDroz'dan ilham aldı

<?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 çıkmadığından ve tarayıcının tüm ilginç çalışmaları yapmasına izin verdiğim için yarışmıyor

JavaScript (ES6), 221

Bir dizi dizge döndüren özyinelemeli olmayan bir işlev (hala içinde özyinelemeli bir alt işlev kullanarak)

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

Bu 2 adımda çalışır.

Adım 1: iç içe geçmiş giriş dizisinin bir dizgisini tekrar tekrar oluşturun. Örnek:

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

Ove Calt diziyi aç ve kapat olarak işaretleyin. Basit sayısal alt diziler boşlukla ayrılmış elemanlarla işlenirken, dizi üyeleri alt diziler ise virgüllerle ayrılırlar. Ben çıkış sadece yerine orta satır alabilirsiniz süre Bu dize, girdi dizisinin düzeyli yapısının izlemek tutar OC,ile |. Tekrarlı olarak bu geçici dizgeyi oluştururken, aynı zamanda maksimum derinlik seviyesini de bulur ve çıktının yarı üst kısmını içerecek bir dizi boş dizgi başlatırım.
Not: Dış kutu yanıltıcıdır, girişi başka bir dış dizinin içine yerleştiririm, sonra gerekli olmayan ilk çıktı sırasını düşürürüm

2. Adım: temp dizesini tarayın ve çıktıyı oluşturun

Şimdi her seviye için bir tane boş dizge var. Her biri için artan ve her biri Oiçin azalan geçerli seviyeyi izleyerek geçici dizgiyi tarıyorum C. Bunu şöyle görselleştiriyorum:

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

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

Artı, aşağı yukarı iner ve mevcut seviyeyi takip eder

Her karakter için, kuralları izleyerek her çıktı sırasına bir karakter eklerim:
- basamak veya boşluk, geçerli düzeye ve altına bir '-' koyarsanız, üstüne bir boşluk koyarsanız
- başka bir deyişle geçerli seviyeye, eğer aşağı ise '-' koy ve '|' eğer yukarıda

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

Geçici taraması sırasında, ben de orta sıra yerine inşa OC,ile|

Bu adımın sonunda ilk yarıyı ve orta sırayı aldım, sadece alt yarıyı almak için üst kısmı yansıtmalıyım ve bitirdim

Daha az golf oynadı, yorum kodu

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

)

Ölçek

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 bayt

Her şeyi kutulara sarmanın yanı sıra her şeyi aynı hizaya getirmek için gereken ek yükü oldukça ağır ...

Spesifikasyona göre, her satırda bir tane olmak üzere, dizelerin dizilerini çıkarır. 1-bayt kaydettiğinden, üst-hizalanmış örnek test durumlarının yerine alta hizalı.

Çevrimiçi deneyin!

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 Bayt

Tüm çözümler, dizinin maksimum derinliği 10'dan daha az olan çalışır. Daha büyük değerler için derinlik bir dizide değil bir dizide saklanmalıdır.

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

Expanded

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 Bayt için bunu REGEX ile yapabiliriz.

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

Expanded

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

Özyinelemeli bir çözüm için 455 Bayt

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

Expanded

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