Proste wyzwanie na poniedziałkowy wieczór (no lub wtorek rano w drugiej połowie świata ...)

Jako dane wejściowe podano zagnieżdżoną, potencjalnie poszarpaną tablicę dodatnich liczb całkowitych:

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

Twoim zadaniem jest określenie jego głębokości, która jest największą głębokością zagnieżdżenia spośród liczb całkowitych na liście. W tym przypadku, głębokość 11Is 6, która jest największa.

Możesz założyć, że żadna z tablic nie będzie pusta.

Możesz napisać program lub funkcję, pobierając dane wejściowe przez STDIN (lub najbliższą alternatywę), argument wiersza poleceń lub argument funkcji i wypisując wynik przez STDOUT (lub najbliższą alternatywę), wartość zwracaną funkcji lub parametr funkcji (wyjściowej).

Dane wejściowe mogą być pobierane w dowolnym dogodnym formacie listy lub ciągu, który obsługuje tablice nie prostokątne (z zagnieżdżonymi tablicami o różnych głębokościach), o ile rzeczywiste informacje nie są przetwarzane wstępnie.

Nie wolno używać żadnych wbudowanych funkcji związanych z kształtem tablic (w tym wbudowanych, które rozwiązują to wyzwanie i które dają wymiary zagnieżdżonej tablicy). Jedynym wyjątkiem jest uzyskanie długości tablicy.

Obowiązują standardowe zasady gry w golfa .

Przypadki testowe

[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 bajty

#,/\

W K ,/połączy wszystkie elementy listy. Wspólny idiom ,//przechodzi do stałego punktu, całkowicie spłaszczając dowolnie zagnieżdżoną listę. ,/\wykona iterację do stałego punktu w podobny sposób, ale zbierze listę wyników pośrednich. Licząc, ile wyników pośrednich odwiedzamy przed osiągnięciem stałego punktu ( #), otrzymujemy pożądaną odpowiedź: maksymalną głębokość zagnieżdżenia.

„Liczba złączy nad skanowaniem w punkcie stałym”.

W akcji:

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

Siatkówka , 10

• Zapisano 1 bajt dzięki @ ӍѲꝆΛҐӍΛПҒЦꝆ
• Zaoszczędź 14 dodatkowych bajtów dzięki @ MartinBüttner

+ `\ w |} {

{

Tutaj format wejściowy jest nieco wymyślony - _znaki są używane do separatorów list, więc dane wejściowe wyglądałyby tak{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Etap 1 - kilkakrotnie usuwaj }{i wszystkie inne \wpostacie. Powoduje to, że a) utworzenie wszystkich list na wszystkich poziomach składa się tylko z jednego elementu oraz b) usunięcie wszystkich znaków niestrukturalnych.
• Etap 2 - pozostało liczyć {. Daje to najgłębszy poziom zagnieżdżenia.

Wypróbuj online.

Jeśli to za dużo, poprzednia odpowiedź brzmiała:

Siatkówka , 13

Zakłada, że ​​listy są zawarte w nawiasach klamrowych {}.

+ `[^} {] |} {

{

Wypróbuj online .

Python 2, 33 bajty

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

Rekurencyjnie definiuje głębokość, mówiąc, że głębokość liczby wynosi 0, a głębokość listy jest o jeden większa niż maksymalna głębokość jej elementów. Liczbę vs listę sprawdza się przez porównanie z pustym słownikiem {}, który znajduje się powyżej liczb, ale poniżej list w arbitralnym porządku wbudowanych typów w Pythonie 2.

Pyth - 11 10 7 bajtów

1 bajt zapisany dzięki @Dennis

4 bajty zapisane dzięki @Thomas Kwa

eU.usNQ

Wypróbuj online tutaj .

Kontynuuje sumowanie tablicy, aż przestanie się zmieniać, co oznacza, że ​​jest to tylko liczba, robi to łącznie, aby zapisać wszystkie wyniki pośrednie i uzyskać długość, wykonując urange o tej samej długości co lista i biorąc ostatni element.

Haskell, 43 bajty

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

Przykład użycia: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"-> 5.

Haskell nie ma mieszanych list ( Integerpomieszanych z List of Integer), więc nie mogę wykorzystać niektórych funkcji wykrywania list i muszę przeanalizować ciąg.

Zaczynam od prawej 0i dodaje 1 dla każdego ], odejmuję 1 dla każdego [i zachowuję wartość w przeciwnym razie. scanrzachowuje wszystkie wyniki pośrednie, więc maximummoże to zrobić.

JavaScript (ES6), 35 bajtów

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

Wyjaśnienie

Funkcja rekurencyjna, która zwraca maksymalną głębokość tablicy lub 0jeśli przekroczyła liczbę.

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 bajtów

'}{'!=dYsX>

Nawiasy klamrowe są używane w MATL dla tego typu tablic. W każdym razie dane wejściowe są pobierane i przetwarzane jako ciąg, więc można również użyć nawiasów kwadratowych, modyfikując dwa znaki w kodzie.

Wypróbuj online!

          % 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

Oktawa, 29 bajtów

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

Odwzorowuje [na 1 i ]na -1, a następnie przyjmuje maksimum łącznej sumy.

Dane wejściowe to ciąg formularza

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

Próbka uruchomiona na ideone .

Julia, 55 26 bajtów

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

Jest to funkcja rekurencyjna, która akceptuje jednowymiarową tablicę z zawartością typu Anyi zwraca liczbę całkowitą. Przekazując tablicę do funkcji, poprzedź wszystkie nawiasy kwadratowe Any, tzn f(Any[1,Any[2,3]]).

Podejście jest dość proste. Dla wejścia a mnożymy a przez 0 i sprawdzamy, czy wynikiem jest skalar 0. Jeśli nie, wiemy, że a jest tablicą, więc zastosujemy funkcję do każdego elementu a , weź maksimum i dodaj 1.

Zaoszczędzono 29 bajtów dzięki Dennisowi!

Rubin, 53 bajty

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

Wejście ze STDIN, wyjście do 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

Galaretka, 10 7 bajtów

¬;/SпL

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

¬;/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.

Aktualizacja

Pisząc tę ​​odpowiedź zauważyłem, że Jelly zachowuje się dość dziwnie w przypadku obdartych list, ponieważ głębokość listy obliczyłem jako zwiększoną minimalną głębokość jej elementów.

Ten problem został rozwiązany w najnowszej wersji, więc teraz działałby następujący kod ( 6 bajtów ).

¬SSпL

To sumuje wiersze tablicy zamiast ich łączenia.

Mathematica, 18 bajtów

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

Mathematica, 27 20 bajtów

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

Prosta funkcja rekurencyjna.

PHP, 61 bajtów

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

funkcja rekurencyjna, która wykorzystuje się jako funkcja mapowania do zastąpienia każdego elementu jego głębokością.

PHP, 84 72 64 63 60 bajtów

Uwaga: wymaga PHP 7 dla połączonego operatora porównania. Wykorzystuje również kodowanie IBM-850

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

Uruchom tak:

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

• Zaoszczędzono 12 bajtów, po prostu licząc nawiasy klamrowe reprezentacji ciągu
• Zaoszczędzono 8 bajtów, upraszczając porównania ciągów i używając liczby porządkowej znaku w przypadku [i]
• Zapisano bajt, nie przesyłając $ido int. Przesunięcia ciągów są rzutowane na wartość domyślną
• Zaoszczędzono 3 bajty przy użyciu połączonego operatora porównania zamiast liczby porządkowej

C, 98 69 bajtów

29 bajtów mniej dzięki @DigitalTrauma !!

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

Pobiera ciąg wejściowy i zwraca wynik jako liczbę całkowitą.

Przykład na żywo w: http://ideone.com/IC23Bc

Python 3, 42 39 bajtów

-3 bajty dzięki Sp3000

Jest to zasadniczo port rozwiązania xnor's Python 2 :

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

Niestety [] > {}zwraca unorderable typesbłąd, więc nie można użyć określonej sprytnej sztuczki xnora. Zamiast tego -0123456789mają niższą wartość ASCII niż A, która jest niższa niż [], dlatego działa porównanie ciągów.

CJam (15 bajtów)

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

Demo online

Sekcja

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

Na tej samej długości, ale raczej na brzydkim terytorium hakerskim,

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

Sed, 40 znaków

(Kod 39 znaków + opcja wiersza poleceń 1 znak.)

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

Dane wejściowe: ciąg znaków, dane wyjściowe: liczba jednostkowa.

Przykładowy przebieg:

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 znaki

(Kod 32 znaków + opcja wiersza poleceń 1 znak).

Jeśli końcowe dane wyjściowe są dozwolone.

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

Dane wejściowe: ciąg znaków, dane wyjściowe: liczba jednostkowa.

Przykładowy przebieg:

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      

Sześciokąt , 61 bajtów

Edycja : Dzięki @Martin Ender ♦ za uratowanie mnie 1 bajtu od cudownej sztuczki -1!

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

Wypróbuj online, aby zweryfikować przypadki testowe!

Poniższe obrazy nie są modyfikowane, ale przepływ jest zasadniczo taki sam. Zauważ też, że zwróci to, -1jeśli dane wejściowe nie są tablicą (tzn. Bez []).

W Hexagonie jest wiele niepotrzebnych operacji ... Wydaje mi się, że można zdecydowanie bardziej grać w golfa.

Wyjaśnienie

W skrócie, dodaje, -1gdy napotyka a [i dodaje, 1gdy napotyka a ]. Wreszcie wypisuje maksimum, jakie ma.

Przebiegnijmy do przypadku testowego 5, aby zobaczyć jego zachowanie, gdy biegnie wzdłuż ciągu [1, [[3]], [5, 6], [[[[8]]]], 1]:

Zaczyna się od początku i bierze swój wkład w rogu W:

Ponieważ nadal jest wprowadzany (nie znak zerowy \0lub EOL), zawija się do góry i rozpoczyna szkarłatną ścieżkę.

Oto, co się stanie, gdy stamtąd będzie słodki ><:

,wczytuje [bufor {i Zustawia stałą Z na 90. 'przesuwa się -na Różnicę i oblicza różnicę. Dla [a ]różnica będzie 1i 3odpowiednio. W przypadku liczb, spacji i przecinków będzie to wartość ujemna.

Następnie biegniemy (dwa razy (raz na końcu szkarłatnej ścieżki, jeden na początku po owijaniu się zieloną ścieżką), aby zdobyć -1i 1odpowiedzieć za [i ]. Tutaj zmieniamy nazwę Diffna Value. Dodaj tę wartość do głębokości. (Kiedyś Z&upewniłem się, że kopiuje właściwego sąsiada). Następnie obliczamy lastMin - Depthi otrzymujemy liczbę na krawędzi pamięci minLR.

Następnie stosujemy &(na końcu zielonej ścieżki) do minLR: Jeśli liczba wynosi <= 0, kopiuje lewą wartość (tj. lastMin - Depth <= 0 => lastMin <= Depth), W przeciwnym razie przyjmuje prawidłową wartość.

Owijamy się do poziomej niebieskiej ścieżki i Z&ponownie widzimy, która kopia minLR. Następnie "&wykonaliśmy kopię obliczonej min. Zakłada się, że nawiasy są zrównoważone, więc min musi wynosić <= 0. Po owinięciu niebieska ścieżka idzie w lewo i uderza (, dzięki czemu kopia jest 1mniejsza niż rzeczywista min. Ponownie wykorzystując -, stworzyliśmy jeszcze jedną jednorazową kopię jako sąsiada bufora:

Uwaga: copyzmieniono nazwę na1-off

Kiedy niebieska ścieżka uderza \i dostaje ładną "i <łapie ją z powrotem do głównej pętli.

Kiedy trafienia pętla 1, ,lub lub inne numery jak wejście:

Różnica stanie się ujemna i zostanie ponownie odzwierciedlona w głównej pętli w celu następnego wejścia.

Kiedy wszystko przeszło przez główną pętlę, dochodzimy do EOL, który tworzy bufor -1i ostatecznie przechodzi do dolnej krawędzi:

'przesuwa MP do 1-off copyi )zwiększa go, a przy ~negacji otrzymuje poprawną wartość Max Depth, którą drukuje się!

I historia kończy się na @.

Chyba muszę trochę skomplikować. Gdybym musiał tylko „cofnąć się” i „wydrukować” bez zwiększania i negowania, zapisałbym 2 bajty bez użycia pełnego sześciokąta.

Ogromne podziękowania dla Timwi za Esoteric IDE i Hexagony Colorer !

pieprzenie mózgu, 48 bajtów

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

Sformatowany:

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

Pobiera sformatowane dane wejściowe (1, ((3)), (5, 6), ((((8)))), 1)i wyświetla wartość bajtu .

Wypróbuj online.

Spowoduje to zapisanie głębokości według lokalizacji pamięci, przesunięcie wskaźnika w prawo (i w lewo )oraz ignorowanie innych znaków. Odwiedzone komórki są oznaczone 1flagą, więc na końcu głównej pętli będziedepth + 1 flagi po prawej stronie bieżącej komórki. Są one następnie dodawane, aby wydrukować końcowy wynik.

Poprzednie 69-bajtowe rozwiązanie wykorzystujące inne podejście:

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

W tej wersji głębokość i maksymalna głębokość są przechowywane bezpośrednio w komórkach.

Pyth, 15 lat 13 bajtów

-2 bajty @Maltysen

eSm-F/Ld`Y._z

Liczy różnicę między skumulowanymi liczbami [i ]i przyjmuje maksimum. Yjest pustą tablicą, a jej ciąg reprezentacji ( `) jest dogodnie[] .

Wypróbuj tutaj .

CJam, 19 22 23 bajtów

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

Podobny pomysł do mojej odpowiedzi MATL.

Podziękowania dla Petera Taylora za usunięcie 3 bajtów

Wypróbuj tutaj

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 bajtów

32 plus dwa za -p

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

Skradziony z cyfrowego Trauma „s Retina odpowiedź ... co jest o 26% krótszy niż ten.:-)

Lub równie:

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

Ruby, 51 znaków

(Zaczęło się jako sugestia ulepszenia Rubinowej odpowiedzi Doorknob , ale zakończyło się inaczej. Więc opublikowałem ją jako osobną odpowiedź. Głosowanie za pomysłem liczenia głębi ( zstępując od ) powinno przejść do oryginalnej odpowiedzi.)?\\<=>$&'] ['.index(c)

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

Dane wejściowe: ciąg znaków, dane wyjściowe: liczba.

Przykładowy przebieg:

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 bajtów

Zamknięcie:

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

Potrzebuje argumentu, np .:

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

Wyjaśnienie:

{ 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
}

Minkolang 0,15 , 31 29 24 bajtów

Zmodyfikowałem mój algorytm na podstawie odpowiedzi CJama Luisa Mendo i zaoszczędziłem 5 bajtów!

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

Wypróbuj tutaj!

Wyjaśnienie

Zasadniczo kod ten utrzymuje bieżącą sumę z +1 dla każdego [ i -1 dla każdego ], śledząc maksymalną osiągniętą wartość, generując to maksimum na końcu. Pętlami zajmuje się toroidalna natura szafki kodowej Minkolanga.

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 znaków

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

Parametr: tablica, powrót: liczba.

Przykładowy przebieg:

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 bajty

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

Bez golfa

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 tworzy jeden wiersz na znak w ciągu wejściowym.

SUBSTR izoluje znak odpowiadający numerowi wiersza.

DECODE tłumaczy każdy „[” na 1, każdy „]” na -1, a każdy inny znak na 0.

SUMA analityczna sumuje każdy 1, -1 i 0 z poprzednich wierszy, w tym bieżącego wiersza;

Sumy MAX to głębokość.

Java 8, 95

To jest wyrażenie lambda dla ToIntFunction<String>. Dane wejściowe są traktowane jako Stringw formacie przykładów PO.

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

dość prosto. Podziel ciąg, używając [jako separatora. Dla każdego z nich zwiększ licznik ei porównaj go z licznikiem d, pozostawiając większy z nich d. Następnie podziel ciąg bieżącej iteracji, używając ]tym razem jako separatora i odejmij liczbę dodatkowych podziałów e.