Đưa ra một mảng có độ sâu bất kỳ, vẽ nội dung của nó với các đường viền +-|xung quanh mỗi phân đoạn. Đó là các ký tự ASCII cho dấu cộng, dấu trừ và đường ống đứng.

Ví dụ, nếu mảng là [1, 2, 3], vẽ

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

Đối với một mảng lồng nhau như [[1, 2, 3], [4, 5], [6, 7, 8]], vẽ

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

Đối với một mảng rách rưới như [[[1, 2, 3], [4, 5]], [6, 7, 8]], vẽ

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

Lưu ý rằng có nhiều không gian hơn sau khi vẽ [6, 7, 8]. Bạn có thể vẽ nội dung trên dòng trên cùng, giữa hoặc dưới cùng, nhưng cho dù bạn chọn gì, bạn vẫn phải nhất quán.

Thử thách này được lấy cảm hứng từ động từ hộp< từ J.

Quy tắc

• Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng.
• Nội dung giải quyết điều này không được phép.
• Mảng đầu vào sẽ chỉ chứa các giá trị nguyên hoặc mảng không âm. Mỗi mảng sẽ đồng nhất, có nghĩa là các phần tử của nó sẽ chỉ bằng các mảng hoặc chỉ các số nguyên, nhưng không bao giờ kết hợp cả hai.
• Mỗi phân đoạn có thể được lồng vào bất kỳ độ sâu nào.
• Đầu ra có thể bằng một chuỗi hoặc một chuỗi các chuỗi trong đó mỗi chuỗi là một dòng đầu ra.

Các trường hợp thử nghiệm

[]
++
||
++

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

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

Cảm ơn ngn vì đã giúp loại bỏ khoảng một phần ba byte.

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

Dùng thử

Xác định chức năng , sau đó chạy từng trường hợp thử nghiệm và so sánh với ]Displaytiện ích tích hợp.
[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]]

Giải trình

Nhìn chung, đây là một chức năng ẩn danh {...}trên đỉnh bao vây ⊂. Cái sau chỉ thêm một mức lồng khác nhắc nhở cái trước thêm khung bên ngoài.

Hàm ẩn danh với khoảng trắng ( ⋄là dấu phân cách câu lệnh):

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

Đây là một lần nữa, nhưng với các chức năng tiện ích riêng biệt:

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

Bây giờ hãy để tôi giải thích từng chức năng:

CloseBoxlấy một bảng và trả về cùng một bảng, nhưng với cột đầu tiên của bảng được nối ở bên phải của bảng. Do đó, được đưa ra bảng 1 nhân 3 XYZ, hàm này trả về bảng 1 x 4 XYZX, như sau:
 ⊢ đối số (nghĩa là bên phải) được đặt
 , trước
 ⊣/ cột ngoài cùng bên trái (giảm. hàng)

CreateVerticallấy một bảng và trả về một chuỗi bao gồm các ký tự sẽ khớp với |s ở hai bên của bảng, nhưng với hai +s được đặt trước để khớp với hai hàng -. Cuối cùng, bảng sẽ được xoay vòng một hàng để có được một +---...hàng bên trên và bên dưới. Do đó, được đưa ra bất kỳ bảng ba hàng nào, hàm này trả về ++|||, như sau:
 '++' , hai phép cộng được đặt trước cho
 '|' ⍴⍨ một
 ≢ cột được định hình lại bởi kiểm đếm (hàng ') của đối số

AddHorizontalslấy một danh sách các danh sách, đặt nó vào một bảng, thêm hai hàng -s ở trên cùng, thêm các ký tự cạnh trái tương ứng ở bên trái, sau đó xoay một hàng xuống phía dưới, để bảng có đường viền ở trên cùng , bên trái và dưới cùng. Như sau:
 1 ⊖ xoay một hàng (hàng trên cùng xuống dưới cùng) của
 CreateVertical , chuỗi được ++|||...thêm vào (dưới dạng cột) để
 '-' ⍪⍣2 trừ đi thêm hai lần vào đầu
 ↑ đối số được chuyển đổi từ danh sách danh sách sang bảng

{Hàm ẩn danh }: Nếu đối số là một danh sách đơn giản (không lồng nhau), hãy đặt nó vào một bảng ký tự (do đó, được đưa ra danh sách 3 phần tử 1 2 3, hàm này trả về bảng ký tự 1 nhân 5 trực quan giống hệt nhau 1 2 3). Nếu đối số không phải là một danh sách đơn giản, hãy đảm bảo các phần tử là các bảng ký tự đơn giản; đệm chúng với chiều cao bằng nhau; đóng khung từng cái trên cùng, dưới cùng và bên trái của chúng; kết hợp chúng; và cuối cùng lấy cột đầu tiên và thêm nó ở bên phải. Như sau:
 { bắt đầu định nghĩa của hàm ẩn danh
  ⍵ ≡ ∊⍵:nếu đối số giống hệt với đối số được làm phẳng (tức là nó là một danh sách đơn giản), sau đó:
   ⍉ hoán  chuyển  đối số được
   ⍪ xâu chuỗi được cột ; khác:  Thêm cột ngoài cùng bên phải của
   ⍉
   ⍕ ⍵
  CloseBox
  ⊃ ,/ những tiết lộ (vì bao quanh giảm) nối-qua
  AddHorizontals¨ add -s trên đỉnh và đáy của mỗi người trong số
  ↓ ↑ ↓¨ các đệm-to-bằng-chiều cao * của
  ∇¨ ⍵  chức năng ẩn danh này áp dụng cho mỗi người trong số các đối số
 } cuối cùng định nghĩa của hàm ẩn danh
* Lit. tạo mỗi bảng thành một danh sách danh sách, kết hợp danh sách danh sách (đệm với chuỗi trống để điền vào các hàng ngắn) vào một bảng, sau đó chia bảng thành danh sách danh sách

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

Giải pháp Ruby của @ MitchSchwartz. Phiên bản trước hoạt động bằng cách gói đệ quy các mảng (và do đó hoạt động cho nội dung tùy ý, không chỉ các số nguyên):

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

Lưu ý: Mặc dù tôi đang sử dụng toán tử trải trong danh sách đối số của mình, để có được đầu ra mong muốn, hãy cung cấp một tham số duy nhất của mảng ban đầu thay vì cố gắng trải rộng mảng; điều này có tác dụng bọc đầu ra trong hộp bên ngoài mong muốn. Đáng buồn thay, hộp bên ngoài tiêu tốn của tôi 18 byte và các số nguyên phân tách không gian tốn 8 byte, nếu không, hình ảnh thay thế sau đây sẽ đủ cho 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'{}',?|}

Hàm ẩn danh mong đợi một chuỗi. Ví dụ: {{{{{4 3 2 1}}}}{{{3 2 1}}}{{2 1}}{1}}sản xuất

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

Bạn có thể sử dụng mã này để thử nghiệm:

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

Điều này bắt đầu từ hàng giữa và hoạt động ra bên ngoài. Đầu tiên, các trường hợp }{được thay thế bằng |. Sau đó, trong khi vẫn còn các dấu ngoặc nhọn, tất cả các {...}chuỗi trong cùng được chuyển thành các +-chuỗi thích hợp trong khi các ký tự khác không |{}được chuyển thành khoảng trắng. Cuối cùng, các thanh giằng trung gian được biến thành ống.

Brainfuck, 423 byte

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

Được định dạng với một số ý kiến:

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

Hãy thử trực tuyến.

Yêu cầu đầu vào được định dạng như (((((4 3 2 1))))(((3 2 1)))((2 1))(1))với một dòng mới và tạo đầu ra của biểu mẫu:

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

Ý tưởng cơ bản là tính toán ký tự nào sẽ được in dựa trên độ sâu của lồng. Định dạng đầu ra sao cho chỉ số hàng của đường viền trên cùng của hộp bằng với độ sâu của mảng tương ứng, với tính đối xứng trên hàng giữa.

Băng được chia thành các nút 7 ô, với mỗi nút đại diện cho một cột trong đầu ra.

Vòng lặp đầu tiên tiêu thụ đầu vào và khởi tạo các nút, theo dõi độ sâu và liệu cột có tương ứng với dấu ngoặc đơn hay không (nghĩa là cột có chứa đường viền dọc hay không) và thu gọn các lần xuất hiện của )(các nút đơn.

Vòng lặp tiếp theo xuất ra một hàng trên mỗi lần lặp. Trong vòng lặp này, một vòng lặp khác đi qua các nút và in một ký tự cho mỗi lần lặp; đây là nơi diễn ra hầu hết các công việc

Trong vòng lặp khởi tạo, bố cục bộ nhớ của một nút khi bắt đầu lặp là

x d 0 c 0 0 0

trong đó xmột cờ boolean cho dù char trước đó là dấu ngoặc đơn đóng, dlà độ sâu (cộng với một) và clà ký tự hiện tại.

Trong vòng lặp in ký tự, bố cục bộ nhớ của một nút khi bắt đầu lặp là

0 0 d1 d2 c p y

trong đó d1chỉ ra độ sâu so với chỉ số hàng cho nửa trên; d2tương tự d1nhưng đối với nửa dưới; clà ký tự đầu vào cho cột đó nếu chữ số hoặc dấu cách, nếu không thì bằng 0; pchỉ ra pha, tức là nửa trên, giữa hoặc nửa dưới; và ylà một lá cờ được truyền từ trái sang phải, theo dõi xem chúng ta đã đạt đến hàng giữa chưa. Lưu ý rằng vì ytrở thành số 0 sau khi xử lý một nút, chúng ta có thể sử dụng yô của nút trước đó để có thêm không gian làm việc.

Thiết lập này cho phép chúng tôi tránh tính toán rõ ràng độ sâu tối đa trong giai đoạn khởi tạo; các ylá cờ được back-tuyên truyền để cập nhật các ptế bào phù hợp.

Có một -1ô ở bên trái của các nút để tạo điều kiện điều hướng và có một ô ở bên phải của các nút theo dõi xem chúng tôi đã in hàng cuối cùng chưa.

PHP + HTML, không cạnh tranh ( 170 141 135 130 byte)

đã lưu 29 byte lấy cảm hứng từ 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>";}

không cạnh tranh vì nó không có đầu ra ascii và vì tôi để trình duyệt làm tất cả công việc thú vị

JavaScript (ES6), 221

Hàm không đệ quy trả về một chuỗi các chuỗi (vẫn sử dụng một hàm con đệ quy bên trong)

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

Điều này hoạt động trong 2 bước.

Bước 1: xây dựng đệ quy một chuỗi đại diện của mảng đầu vào lồng nhau. Thí dụ:

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

Ovà Cđánh dấu subarray mở và đóng. Các tập hợp con số đơn giản được hiển thị với các phần tử được phân tách bằng dấu cách, trong khi nếu các thành viên mảng là các tập hợp con thì chúng được phân tách bằng dấu phẩy. Chuỗi này theo dõi cấu trúc đa cấp của mảng đầu vào, trong khi tôi có thể lấy hàng giữa của đầu ra chỉ cần thay thế OC,bằng |. Trong khi xây dựng đệ quy chuỗi tạm thời này, tôi cũng tìm thấy mức độ sâu tối đa và khởi tạo một chuỗi các chuỗi trống sẽ chứa một nửa phần trên cùng của đầu ra.
Lưu ý: hộp bên ngoài là khó khăn, tôi lồng đầu vào bên trong một mảng bên ngoài khác, sau đó tôi đã bỏ hàng đầu ra đầu tiên không cần thiết

Bước 2: quét chuỗi tạm thời và xây dựng đầu ra

Bây giờ tôi có một chuỗi các chuỗi trống, mỗi chuỗi cho mỗi cấp độ. Tôi quét chuỗi tạm thời, theo dõi mức hiện tại, tăng cho từng Ovà giảm cho từng chuỗi C. Tôi hình dung điều này như thế:

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

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

Cộng với tăng giảm theo mức hiện tại

Đối với mỗi char, tôi thêm một ký tự vào mỗi hàng đầu ra, theo các quy tắc:
- nếu chữ số hoặc dấu cách, đặt '-' ở mức hiện tại và bên dưới, đặt khoảng trắng ở trên
- khác, đặt '+' ở mức hiện tại, đặt '-' nếu bên dưới và đặt '|' nếu ở trên

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

Trong quá trình quét tạm thời, tôi cũng xây dựng hàng giữa thay thế OC,bằng|

Ở cuối bước này, tôi có nửa trên và hàng giữa, tôi chỉ phải phản chiếu phần trên để có được nửa dưới và tôi đã hoàn thành

Ít chơi gôn, nhận xét mã

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

)

Kiểm tra

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

Chi phí cần thiết để bọc mọi thứ trong hộp cũng như sắp xếp mọi thứ khá nặng ...

Xuất ra các mảng của chuỗi, với một chuỗi trên mỗi dòng, theo thông số kỹ thuật. Căn chỉnh dưới cùng thay vì các trường hợp kiểm tra mẫu được căn chỉnh trên cùng vì nó tiết kiệm 1 byte.

Hãy thử trực tuyến!

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

Tất cả các giải pháp hoạt động với độ sâu tối đa của mảng nhỏ hơn 10. đối với các giá trị lớn hơn, độ sâu phải lưu trữ trong một mảng chứ không phải trong một chuỗi.

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

Mở rộng

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

với 425 Byte, chúng ta có thể thực hiện điều này với 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)));

Mở rộng

$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 cho một giải pháp đệ quy

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

Mở rộng

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