Một thử thách đơn giản cho buổi tối thứ Hai của bạn (tốt, hoặc sáng thứ Ba ở nửa kia của thế giới ...)

Bạn được cung cấp dưới dạng đầu vào một mảng các số nguyên dương lồng nhau, có khả năng rách nát:

[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]

Nhiệm vụ của bạn là xác định độ sâu của nó, độ sâu lồng nhau lớn nhất của bất kỳ số nguyên nào trong danh sách. Trong trường hợp này, độ sâu của 11là 6, đó là lớn nhất.

Bạn có thể cho rằng không có mảng nào sẽ trống.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đầu vào có thể được lấy trong bất kỳ danh sách thuận tiện hoặc định dạng chuỗi nào hỗ trợ các mảng không phải hình chữ nhật (với các mảng lồng nhau có độ sâu khác nhau), miễn là thông tin thực tế không được xử lý trước.

Bạn không được sử dụng bất kỳ phần dựng sẵn nào liên quan đến hình dạng của mảng (bao gồm cả phần dựng sẵn giải quyết thách thức này, giúp bạn có được kích thước của một mảng lồng nhau). Ngoại lệ duy nhất này là nhận được chiều dài của một mảng.

Luật golf tiêu chuẩn được áp dụng.

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

[1]                                                               -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7

K, 4 byte

#,/\

Trong K, ,/sẽ tham gia tất cả các yếu tố của một danh sách. Thành ngữ phổ biến ,//lặp lại đến một điểm cố định, làm phẳng hoàn toàn một danh sách lồng nhau tùy ý. ,/\sẽ lặp lại đến một điểm cố định theo cách tương tự, nhưng thu thập một danh sách các kết quả trung gian. Bằng cách đếm có bao nhiêu kết quả trung gian mà chúng tôi truy cập trước khi đạt đến điểm cố định ( #), chúng tôi nhận được câu trả lời chúng tôi muốn: độ sâu lồng tối đa.

"Đếm tham gia qua quét điểm cố định".

Trong hành động:

 (#,/\)'(,1
        1 2 3
        ,1 2 3
        (3;(3;,3;3);3)
        ,((,1;2);(3;,4)))
1 1 2 3 4

Võng mạc , 10

• Đã lưu 1 byte nhờ @ ӍѲꝆΛҐӍΛNETҒЦꝆ
• Đã lưu thêm 14 byte nhờ @ MartinBüttner

+ `\ w |} {

{

Ở đây định dạng đầu vào là một chút giới hạn - các _ký tự được sử dụng cho các dấu tách danh sách, vì vậy một đầu vào sẽ trông như thế này{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Giai đoạn 1 - liên tục xóa }{và tất cả các mục khác\w nhân vật . Điều này có tác dụng của a) làm cho tất cả các danh sách ở tất cả các cấp chỉ bao gồm một yếu tố và b) loại bỏ tất cả các ký tự không có cấu trúc danh sách.
• Giai đoạn 2 - đếm còn lại {. Điều này cho mức độ làm tổ sâu nhất.

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

Nếu đó là quá nhiều, thì câu trả lời trước đó là:

Võng mạc , 13

Danh sách giả định được chứa trong dấu ngoặc nhọn {} .

+ `[^} {] |} {

{

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

Python 2, 33 byte

f=lambda l:l>{}and-~max(map(f,l))

Định nghĩa đệ quy độ sâu bằng cách nói độ sâu của một số là 0 và độ sâu của danh sách là nhiều hơn độ sâu tối đa của các phần tử. Số so với danh sách được kiểm tra bằng cách so sánh với từ điển trống {}, nằm trên các số nhưng bên dưới danh sách theo thứ tự tùy ý các loại tích hợp của Python 2.

Pyth - 11 10 7 byte

Lưu 1 byte nhờ @Dennis

4 byte được lưu nhờ @Thomas Kwa

eU.usNQ

Dùng thử trực tuyến tại đây .

Tiếp tục tổng hợp mảng cho đến khi nó dừng thay đổi, có nghĩa là nó chỉ là một số, thực hiện điều này một cách tích lũy để lưu tất cả các kết quả trung gian và có được độ dài bằng cách tạo một urange có cùng độ dài như danh sách và lấy phần tử cuối cùng.

Haskell, 43 byte

'['#x=x-1
']'#x=x+1
_#x=x
maximum.scanr(#)0

Ví dụ sử dụng: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"-> 5.

Haskell không có danh sách hỗn hợp ( Integertrộn với List of Integer), vì vậy tôi không thể khai thác một số chức năng phát hiện danh sách và tôi phải phân tích chuỗi.

Tôi bắt đầu ở bên phải với 0và thêm 1 cho mỗi ], trừ 1 cho mỗi [và giữ giá trị khác. scanrgiữ tất cả các kết quả trung gian, vì vậy maximumcó thể làm việc đó.

JavaScript (ES6), 35 byte

f=a=>a[0]?Math.max(...a.map(f))+1:0

Giải trình

Hàm đệ quy trả về độ sâu tối đa của một mảng hoặc 0nếu được truyền một số.

var solution =

f=a=>
  a[0]?                   // if a is an array
    Math.max(...a.map(f)) // return the maximum depth of each element in the array
    +1                    // add 1 to increase the depth
  :0                      // if a is a number, return 0

// Test cases
result.textContent =
`[1]                                                              -> 1
[1, 2, 3]                                                         -> 1
[[1, 2, 3]]                                                       -> 2
[3, [3, [3], 3], 3]                                               -> 3
[[[[1], 2], [3, [4]]]]                                            -> 4
[1, [[3]], [5, 6], [[[[8]]]], 1]                                  -> 5
[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14] -> 6
[[[[[[[3]]]]]]]                                                   -> 7`
.split`\n`.map(t=>(c=t.split`->`.map(p=>p.trim()),c[0]+" == "+c[1]+": "+(solution(eval(c[0]))==c[1]?"Passed":"Failed"))).join`\n`

<input type="text" id="input" value="[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]" />
<button onclick="result.textContent=solution(eval(input.value))">Go</button>
<pre id="result"></pre>

MATL , 11 14 15 byte

'}{'!=dYsX>

Niềng răng xoăn được sử dụng trong MATL cho loại mảng này. Dù sao, đầu vào được lấy và xử lý dưới dạng một chuỗi, vì vậy dấu ngoặc vuông có thể được sử dụng như nhau, sửa đổi hai ký tự trong mã.

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

          % implicitly take input as a string (row array of chars)
'}{'!     % 2x1 (column) char array with the two curly brace symbols
=         % 2-row array. First / second row contains 1 where '}' / '{' is found
d         % second row minus first row
Ys        % cumulative sum of the array
X>        % maximum of the array
          % implicitly display result

Octave, 29 byte

@(a)max(cumsum(92-(a(a>90))))

Bản đồ [thành 1 và ]đến -1, sau đó lấy tối đa tổng tích lũy.

Đầu vào là một chuỗi các hình thức

S6 = '[1, [[3]], [5, 6], [[[[8]]]], 1]';

Mẫu chạy trên ideone .

Julia, 55 26 byte

f(a)=0a!=0&&maximum(f,a)+1

Đây là hàm đệ quy chấp nhận mảng một chiều có nội dung kiểu Anyvà trả về một số nguyên. Khi truyền một mảng cho hàm, tiền tố tất cả các dấu ngoặc có Anynghĩa là f(Any[1,Any[2,3]]).

Cách tiếp cận khá đơn giản. Đối với đầu vào a , chúng ta nhân a với 0 và kiểm tra xem kết quả có phải là vô hướng 0. Nếu không, chúng ta biết rằng a là một mảng, vì vậy chúng ta áp dụng hàm cho từng phần tử của a , lấy tối đa và thêm 1.

Đã lưu 29 byte nhờ Dennis!

Ruby, 53 byte

i=0;p gets.chars.map{|c|i+=('] ['.index(c)||1)-1}.max

Đầu vào từ STDIN, đầu ra đến STDOUT.

i=0;                 initialize counter variable
p                    output to STDOUT...
gets                 get line of input
.chars               enumerator of each character in the input
.map{|c|             map each character to...
i+=                  increment i (and return the new value) by...
('] ['.index(c)||1)  returns 0 for ], 2 for [, 1 for anything else
-1                   now it's -1 for ], 1 for [, 0 for anything else
                     therefore: increment i on increase in nesting, decrement i
                       on decrease, do nothing otherwise
}.max                find the highest nesting level that we've seen

Thạch, 10 7 byte

¬;/SпL

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

¬;/SпL  Main link. Input: A (list)

¬        Negate all integers in A. This replaces them with zeroes.
    п   Cumulative while loop.
   S       Condition: Compute the sum of all lists in A.
                      If the sum is an integer, it will be zero (hence falsy).
 ;/        Body:      Concatenate all lists in A.
      L  Count the number of iterations.

Cập nhật

Trong khi viết câu trả lời này, tôi nhận thấy rằng Jelly hành xử khá kỳ lạ đối với các danh sách rách rưới, bởi vì tôi đã tính độ sâu của danh sách khi tăng dần độ sâu tối thiểu của các mục.

Điều này đã được giải quyết trong phiên bản mới nhất, vì vậy đoạn mã sau ( 6 byte ) sẽ hoạt động ngay bây giờ.

¬SSпL

Điều này tính tổng các hàng của mảng thay vì nối chúng.

Toán học, 18 byte

Max@#+1&//@(0#-1)&

Toán học, 27 20 byte

Max[#0/@#]+1&[0#]-1&

Hàm đệ quy đơn giản.

PHP, 61 byte

function d($a){return is_array($a)?1+max(array_map(d,$a)):0;}

hàm đệ quy sử dụng chính nó như một hàm ánh xạ để thay thế từng phần tử bằng độ sâu của nó.

PHP, 84 72 64 63 60 byte

Lưu ý: yêu cầu PHP 7 cho toán tử so sánh kết hợp. Cũng sử dụng mã hóa IBM-850

for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;

Chạy như thế này:

php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"

• Thay vào đó, đã lưu 12 byte bằng cách đếm các dấu ngoặc của biểu diễn chuỗi
• Đã lưu 8 byte bằng cách đơn giản hóa các so sánh chuỗi và sử dụng số thứ tự của char trong trường hợp [ và]
• Đã lưu một byte bằng cách không truyền $i tới int. Chuỗi bù đắp được truyền tới một int ngầm
• Đã lưu 3 byte bằng cách sử dụng toán tử so sánh kết hợp thay vì số thứ tự

C, 98 69 byte

Tắt 29 byte cảm ơn @DigitalTrauma !!

r,m;f(char*s){for(r=m=0;*s;r-=*s++==93)r+=*s==91,m=r>m?r:m;return m;}

Mất một chuỗi làm đầu vào và trả về kết quả dưới dạng số nguyên.

Ví dụ trực tiếp trong: http://ideone.com/IC23Bc

Python 3, 42 39 byte

-3 byte nhờ Sp3000

Đây thực chất là một cổng của giải pháp Python 2 của xnor :

f=lambda l:"A"<str(l)and-~max(map(f,l))

Thật không may, [] > {}trả về một unorderable typeslỗi, do đó không thể sử dụng thủ thuật thông minh cụ thể của xnor. Ở vị trí của nó, -0123456789giá trị ASCII Athấp hơn [], thấp hơn , do đó so sánh chuỗi hoạt động.

CJam (15 byte)

q~{__e_-M*}h],(

Bản demo trực tuyến

Mổ xẻ

q~      e# Read line and parse to array
{       e# Loop...
  _     e#   Leave a copy of the array on the stack to count it later
  _e_-  e#   Remove a flattened version of the array; this removes non-array elements from
        e#   the top-level array.
  M*    e#   Remove one level from each array directly in the top-level array
}h      e# ...until we get to an empty array
],(     e# Collect everything together, count and decrement to account for the extra []

Với cùng chiều dài nhưng hơn thế nữa là trong lãnh thổ hack xấu xí,

q'[,-{:~_}h],2-

Sed, 40 ký tự

(Mã 39 ký tự + 1 ký tự tùy chọn dòng lệnh.)

s/[^][]+//g
:;s/]\[//;t
s/]//g
s/\[/1/g

Đầu vào: chuỗi, đầu ra: số đơn nguyên.

Chạy mẫu:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;s/]//g;s/\[/1/g' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111

Sed, 33 ký tự

(Mã 32 ký tự + 1 ký tự tùy chọn dòng lệnh.)

Nếu dấu cách được cho phép trong đầu ra.

s/[^][]+//g
:;s/]\[//;t
y/[]/1 /

Đầu vào: chuỗi, đầu ra: số đơn nguyên.

Chạy mẫu:

bash-4.3$ sed -r 's/[^][]+//g;:;s/]\[//;t;y/[]/1 /' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
111111      

Lục giác , 61 byte

Chỉnh sửa : Cảm ơn @Martin Ender ♦ vì đã tiết kiệm cho tôi 1 byte từ thủ thuật -1 tuyệt vời!

|/'Z{>"-\..(.."/'&<'..{>-&,=+<$.{\$._{..><.Z=/...({=Z&"&@!-"

Hãy thử trực tuyến để xác minh các trường hợp thử nghiệm!

Các hình ảnh dưới đây không được sửa đổi nhưng về cơ bản là giống nhau. Cũng lưu ý rằng điều này sẽ trả về -1nếu đầu vào không phải là một mảng (tức là không có[] ).

Tôi có rất nhiều no-op bên trong Hexagon ... Tôi đoán nó chắc chắn có thể được chơi gôn nhiều hơn.

Giải trình

Tóm lại, nó thêm -1khi gặp a [và thêm 1khi gặp a] . Cuối cùng, nó in tối đa nó có.

Chúng ta hãy chạy dọc Test Case 5 để xem hành vi của nó khi nó chạy dọc theo String [1, [[3]], [5, 6], [[[[8]]]], 1] :

Nó bắt đầu từ đầu và lấy đầu vào của nó ở góc W:

Vì vẫn còn đầu vào (không phải ký tự null \0 hoặc EOL), nó sẽ kết thúc ở đầu và bắt đầu đường dẫn màu đỏ thẫm.

Đây là những gì xảy ra khi từ đó đến dễ thương >< :

,đọc [vào Bộ đệm {và Zđặt hằng số Z là 90. 'di chuyển đến Diff và -tính toán sự khác biệt. Cho [và ]sự khác biệt sẽ được 1và 3tương ứng. Đối với số và dấu cách và dấu phẩy, nó sẽ âm.

Sau đó chúng tôi chạy (hai lần (một lần vào cuối con đường màu đỏ thẫm, một lúc bắt đầu sau khi gói tại con đường màu xanh lá cây) để có được -1và 1resp cho [và ]. Ở đây chúng ta thay đổi cách đặt tên của Diffđể Value. Thêm giá trị này vào độ sâu. (Tôi đã sử dụng Z&để đảm bảo rằng nó sao chép đúng hàng xóm). Sau đó, chúng tôi tính toán lastMin - Depthvà có một số trên cạnh Bộ nhớminLR .

Sau đó, chúng tôi áp dụng &(ở cuối đường dẫn màu xanh lá cây) cho minLR: Nếu số đó là <= 0, nó sẽ sao chép giá trị bên trái (nghĩa làlastMin - Depth <= 0 => lastMin <= Depth ), nếu không, nó sẽ lấy giá trị bên phải.

Chúng tôi kết thúc với đường dẫn màu xanh nằm ngang và chúng tôi sẽ thấy Z&lại bản sao nào minLR. Sau đó, chúng tôi "&và tạo một bản sao của min tính toán. Các dấu ngoặc được coi là cân bằng, vì vậy min phải <= 0. Sau khi bọc, đường dẫn màu xanh đi sang trái và nhấn (, làm cho bản sao 1nhỏ hơn min thực. Sử dụng lại -, chúng tôi đã tạo thêm một bản sao 1 lần nữa với tư cách là hàng xóm của Buffer:

Lưu ý: copyđược đổi tên thành1-off

Khi con đường màu xanh chạm \và có một tốt đẹp "và< bắt nó trở lại vòng lặp chính.

Khi hit vòng lặp 1, ,hoặc hoặc số khác như là đầu vào:

Diff sẽ trở nên âm và nó được phản ánh trở lại vòng lặp chính cho đầu vào tiếp theo.

Khi mọi thứ đã đi qua vòng lặp chính, chúng ta sẽ đến EOL, điều này tạo ra Buffer -1và cuối cùng nó đi đến cạnh dưới cùng:

'di chuyển MP đến 1-off copyvà )tăng nó, và với ~phủ định, nó có giá trị Độ sâu tối đa chính xác được in bằng!

Và câu chuyện kết thúc với a @.

Tôi đoán tôi phải phức tạp hóa mọi thứ một chút. Nếu tôi chỉ phải "di chuyển trở lại" và "in" mà không tăng và phủ định, tôi sẽ lưu được 2 byte mà không cần sử dụng Hexagon đầy đủ.

Rất cảm ơn Timwi cho IDE bí truyền và Hexagony Colorer !

Brainfuck, 48 byte

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

Định dạng:

,
[
  <++[>-<------]>++
  [
    not close paren
    +
    [
      not open paren
      <
    ]
    >>[-]
  ]
  +<,
]
-[<[>+<-]>>]
<.

Đưa đầu vào được định dạng như (1, ((3)), (5, 6), ((((8)))), 1) và xuất ra một giá trị byte .

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

Điều này lưu trữ độ sâu theo vị trí bộ nhớ, di chuyển con trỏ sang phải (và trái )và bỏ qua các ký tự khác. Các ô được truy cập được đánh dấu bằng một 1cờ, vì vậy ở cuối vòng lặp chính sẽ códepth + 1 cờ ở bên phải của ô hiện tại. Chúng sau đó được thêm vào để in kết quả cuối cùng.

Một giải pháp 69 byte trước đó sử dụng một cách tiếp cận khác:

,
[
  >>++[<<->>------]<-<++
  [
    not close paren
    >++<+
    [
      not open paren
      >-<[-]
    ]
  ]
  <
  [
    [>+>]
    <[<-<]
    >
  ]
  >>[<+> >+<-]
  ,
]
<.

Trong phiên bản này, độ sâu và độ sâu tối đa được lưu trữ rõ ràng trong các ô.

Bình thường, 15 13 byte

-2 byte bởi @Maltysen

eSm-F/Ld`Y._z

Đếm sự khác biệt giữa số tích lũy của [và ], và lấy mức tối đa. Ylà mảng trống và biểu diễn chuỗi của nó ( `) thuận tiện [].

Hãy thử nó ở đây .

CJam, 19 22 23 byte

0l{_91=\93=-+_}%:e>

Ý tưởng tương tự với câu trả lời MATL của tôi.

Cảm ơn Peter Taylor đã xóa 3 byte

Hãy thử nó ở đây

0                            push a 0
l                            read line as string
{            }%              map this block on the string
  _91=\93=-                  1 if it's an opening bracket, -1 if closing
           +_                cumulative sum
               :e>           fold maximum function

Perl 5, 34 byte

32, cộng hai cho -p

{s&]\[|[^][]&&g&&redo}$_=@a=/]/g

Bị đánh cắp từ câu trả lời Retina của Digital Trauma , câu trả lời ngắn hơn 26%.:-)

Hoặc, bằng nhau:

{s&]\[|[^][]&&g&&redo}$_=y///c/2

Ruby, 51 ký tự

(Bắt đầu là đề xuất cải tiến cho câu trả lời Ruby của Doorknob nhưng kết thúc khác nhau. Vì vậy, tôi đã đăng nó dưới dạng câu trả lời riêng. Upvote cho ý tưởng đếm sâu ( , giảm dần ) nên đi đến câu trả lời ban đầu.)?\\<=>$&'] ['.index(c)

m=i=0
gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max}
p m

Đầu vào: chuỗi, đầu ra: số.

Chạy mẫu:

bash-4.3$ ruby -e 'm=i=0;gets.gsub(/\[|\]/){m=[m,i+=?\\<=>$&].max};p m' <<< '[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]'
6

Perl 6, 53 byte

Việc đóng cửa:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}

Cần một đối số, ví dụ:

{my ($m,$d);/[\[{$d++;$m=max $m,$d}|\]{$d--}|.]*/;$m}("[[[3]][2]]")
3

Giải trình:

{ my ($m,$d);                 # start closure, declare variables    

  /                           # start regex match

   [                          # start (non-capturing) group

     \[ {$d++;$m=max $m,$d} | # match [ and track depth; OR

     \] {$d--}              | # match ] and track depth; OR

     .                        # match one character

   ]*                         # repeat group

  /;                          # end regex

  $m                          # return max depth
}

Chồn 0,15 , 31 29 24 byte

Đại tu thuật toán của tôi dựa trên cảm hứng từ câu trả lời CJam của Luis Mendo và lưu 5 byte!

od5&j$ZN.d"["=$r"]"=~++d

Hãy thử nó ở đây!

Giải trình

Về cơ bản, những gì mã này làm là giữ tổng cộng chạy với +1 cho mỗi [và -1 cho mỗi ], theo dõi giá trị tối đa đạt được, xuất ra mức tối đa đó ở cuối. Looping được xử lý bởi bản chất hình xuyến của codebox của Minkolang.

od           Take character from input and duplicate it (0 if input is empty)
  5&         Pop top of stack and skip the following five spaces if 0
    j$Z      Push the maximum value of the stack
       N.    Output as number and stop.

  d                  Duplicate top of stack for character tests
   "["=              +1 if the character is [
       $r            Swap top two items of stack
         "]"=~       -1 if the character is ]
              ++     Add twice
                d    Duplicate top of stack for the running total

Ruby, 41 ký tự

f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}

Tham số: mảng, trả về: số.

Chạy mẫu:

2.1.5 :001 > f=->a,d=1{a.map{|e|f[e,d+1]rescue d}.max}
 => #<Proc:0x0000000214d258@(irb):1 (lambda)> 

2.1.5 :002 > f[[1, [[2, 3, [[4], 5], 6, [7, 8]], 9, [10, [[[11]]]], 12, 13], 14]]
 => 6 

Oracle SQL 11.2, 133 byte

SELECT MAX(d)FROM(SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL)d FROM DUAL CONNECT BY LEVEL<=LENGTH(:1));

Không chơi gôn

SELECT MAX(d)
FROM   (
         SELECT SUM(DECODE(SUBSTR(:1,LEVEL,1),'[',1,']',-1,0))OVER(ORDER BY LEVEL) d 
         FROM   DUAL 
         CONNECT BY LEVEL<=LENGTH(:1)
       );

CONNECT BY tạo một hàng cho mỗi ký tự trong chuỗi đầu vào.

SUBSTR cô lập ký tự tương ứng với số hàng.

DECODE dịch từng '[' thành 1, mỗi ']' thành -1 và mọi ký tự khác thành 0.

SUM phân tích tính tổng mỗi 1, -1 và 0 từ các hàng trước, bao gồm hàng hiện tại;

Các khoản tiền MAX là độ sâu.

Java 8, 95

Đây là một biểu thức lambda cho a ToIntFunction<String>. Đầu vào được lấy dưới Stringdạng định dạng của OP.

s->{int d=e=-1;for(String t:s.split("[")){d=++e>d?e:d;e-=t.split("]",-1).length()-1;}return d;}

khá đơn giản. Tách chuỗi bằng cách sử dụng [dấu phân cách. Đối với mỗi người trong số họ, tăng bộ đếm evà so sánh nó với bộ đếm d, giữ cho bộ đếm lớn hơn d. Sau đó, phân tách chuỗi lặp hiện tại bằng cách sử dụng ]dấu phân cách lần này và trừ đi số lần phân tách bổ sung từ đó e.