Eine einfache Herausforderung für Ihren Montagabend (na ja, oder Dienstagmorgen in der anderen Hälfte der Welt ...)

Sie erhalten als Eingabe ein verschachteltes, möglicherweise uneinheitliches Array positiver Ganzzahlen:

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

Ihre Aufgabe ist es, die Tiefe zu bestimmen, die die größte Verschachtelungstiefe aller Ganzzahlen in der Liste ist. In diesem Fall wird die Tiefe 11heißt 6, die am größten ist .

Sie können davon ausgehen, dass keines der Arrays leer ist.

Sie können ein Programm oder eine Funktion schreiben, indem Sie eine Eingabe über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument vornehmen und das Ergebnis über STDOUT (oder die nächstgelegene Alternative), einen Funktionsrückgabewert oder einen Funktionsparameter (out) ausgeben.

Die Eingabe kann in einem beliebigen geeigneten Listen- oder Zeichenfolgenformat erfolgen, das nicht rechteckige Arrays (mit verschachtelten Arrays unterschiedlicher Tiefe) unterstützt, sofern die eigentlichen Informationen nicht vorverarbeitet wurden.

Sie dürfen keine eingebauten Elemente verwenden, die mit der Form von Arrays zusammenhängen (einschließlich eingebauter Elemente, die diese Herausforderung lösen und die Abmessungen eines verschachtelten Arrays liefern). Die einzige Ausnahme ist das Abrufen der Länge eines Arrays.

Es gelten die Standardregeln für Code-Golf .

Testfälle

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

#,/\

In K ,/werden alle Elemente einer Liste verbunden. Das gemeinsame Idiom ,//iteriert bis zu einem festen Punkt, wodurch eine beliebig verschachtelte Liste vollständig abgeflacht wird. ,/\wird auf ähnliche Weise zu einem festen Punkt iterieren, aber eine Liste von Zwischenergebnissen zusammenstellen. Indem wir zählen, wie viele Zwischenergebnisse wir besuchen, bevor wir den Fixpunkt ( #) erreichen, erhalten wir die gewünschte Antwort: die maximale Verschachtelungstiefe.

Msgstr "Anzahl der Verknüpfungen über Festkomma - Scan".

In Aktion:

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

Retina , 10

• 1 Byte dank @ ӍѲꝆΛҐӍΛПӍѲꝆΛҐӍΛ gespeichert
• 14 zusätzliche Bytes dank @ MartinBüttner eingespart

+ `\ w |} {

{

Hier ist das Eingabeformat ein wenig überlegt - _Zeichen werden für Listentrennzeichen verwendet, so dass eine Eingabe wie folgt aussehen würde{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Stufe 1 - wiederholt entfernen }{und alle anderen \wZeichen. Dies hat zur Folge, dass a) alle Listen auf allen Ebenen aus nur einem Element bestehen und b) alle nicht-listenstrukturellen Zeichen entfernt werden.
• Stufe 2 - verbleibende Zählung {. Dies ergibt die tiefste Verschachtelungsebene.

Probieren Sie es online aus.

Wenn das zu viel ist, dann war die vorherige Antwort:

Retina , 13

Angenommen, Listen sind in geschweiften Klammern enthalten {}.

+ `[^} {] |} {

{

Probieren Sie es online aus .

Python 2, 33 Bytes

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

Definiert die Tiefe rekursiv, indem gesagt wird, dass die Tiefe einer Zahl 0 ist und die Tiefe einer Liste eins mehr als die maximale Tiefe ihrer Elemente ist. Die Prüfung der Anzahl gegenüber der Liste erfolgt durch Vergleich mit dem leeren Wörterbuch {}, das über den Zahlen, aber unter den Listen in der willkürlichen Reihenfolge der integrierten Typen in Python 2 liegt.

Pyth - 11 10 7 Bytes

Dank @Dennis 1 Byte gespart

Dank @Thomas Kwa 4 Bytes gespart

eU.usNQ

Probieren Sie es hier online aus .

Summiert das Array so lange, bis es sich nicht mehr ändert, was bedeutet, dass es nur noch eine Zahl ist. Dies geschieht kumulativ, um alle Zwischenergebnisse zu speichern und die Länge zu ermitteln, indem ein Urange mit der gleichen Länge wie list erstellt und das letzte Element verwendet wird.

Haskell, 43 Bytes

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

Anwendungsbeispiel: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"->5 .

Haskell hat keine gemischten Listen (Integer gemischt mit List of Integer), daher kann ich einige Listenerkennungsfunktionen nicht ausnutzen und muss die Zeichenfolge analysieren.

Ich beginne rechts mit 0und addiere 1 für jeden ], subtrahiere 1 für jeden [und behalte den Wert ansonsten bei. scanrbehält alle Zwischenergebnisse, maximumkann also seine Arbeit tun.

JavaScript (ES6), 35 Byte

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

Erläuterung

Rekursive Funktion, die die maximale Tiefe eines Arrays oder 0eine übergebene Zahl zurückgibt .

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 Bytes

'}{'!=dYsX>

In MATL werden für diese Art von Arrays geschweifte Klammern verwendet. Auf jeden Fall wird die Eingabe als Zeichenfolge verarbeitet, sodass auch eckige Klammern verwendet werden können, um die beiden Zeichen im Code zu ändern.

Probieren Sie es 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

Oktave, 29 Bytes

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

Ordnet [1 und ]-1 zu und berechnet dann das Maximum der kumulierten Summe.

Die Eingabe ist eine Zeichenfolge des Formulars

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

Probelauf auf ideone .

Julia, 55 26 Bytes

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

Dies ist eine rekursive Funktion, die ein eindimensionales Array mit Inhalten vom Typ akzeptiert Anyund eine Ganzzahl zurückgibt. Wenn Sie ein Array an die Funktion übergeben, müssen Sie allen Klammern das Präfix " Any, dh" voranstellenf(Any[1,Any[2,3]]) .

Der Ansatz ist ziemlich einfach. Für eine Eingabe a multiplizieren wir a mit 0 und prüfen, ob das Ergebnis der Skalar 0 ist. Wenn nicht, wissen wir, dass a ein Array ist, also wenden wir die Funktion auf jedes Element von a an , nehmen das Maximum und addieren 1.

29 Bytes gespart dank Dennis!

Ruby, 53 Bytes

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

Eingabe von STDIN, Ausgabe an 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

Gelee, 10 7 Bytes

¬;/SпL

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Aktualisieren

Während ich diese Antwort schrieb, bemerkte ich, dass sich Jelly für unregelmäßige Listen ziemlich seltsam verhält, weil ich die Tiefe einer Liste als das inkrementierte Minimum der Tiefe ihrer Elemente berechnet habe .

Dies wurde in der neuesten Version behoben, sodass der folgende Code ( 6 Byte ) jetzt funktionieren würde.

¬SSпL

Dies summiert die Zeilen des Arrays, anstatt sie zu verketten.

Mathematica, 18 Bytes

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

Mathematica, 27 20 Bytes

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

Einfache rekursive Funktion.

PHP, 61 Bytes

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

rekursive Funktion, die sich selbst als Zuordnungsfunktion verwendet, um jedes Element durch seine Tiefe zu ersetzen.

PHP, 84 72 64 63 60 Bytes

Hinweis: Erfordert PHP 7 für den kombinierten Vergleichsoperator. Verwendet auch IBM-850-Codierung

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

Laufen Sie wie folgt:

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

• 12 Bytes wurden eingespart, indem stattdessen nur geschweifte Klammern der Zeichenfolgendarstellung gezählt wurden
• Durch Vereinfachung der Zeichenfolgenvergleiche und Verwendung der Ordnungszahl des Zeichens bei [und 8 Byte gespart]
• Ein Byte wurde gespeichert, indem nicht $iauf ein int gewechselt wurde. String-Offsets werden implizit in ein int umgewandelt
• 3 Bytes mit dem kombinierten Vergleichsoperator anstelle der Ordnungszahl gespeichert

C 98 69 Bytes

29 Bytes weg danke @DigitalTrauma !!

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

Nimmt eine Zeichenfolge als Eingabe und gibt das Ergebnis als Ganzzahl zurück.

Live-Beispiel in: http://ideone.com/IC23Bc

Python 3, 42 39 Bytes

-3 Bytes dank Sp3000

Dies ist im Wesentlichen eine Portierung der Python 2-Lösung von xnor :

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

Gibt leider [] > {}einen unorderable typesFehler zurück, so dass ein bestimmter cleverer Trick von xnor's nicht verwendet werden kann. An seiner Stelle -0123456789sind die ASCII-Werte niedriger als A, was niedriger als ist [], daher funktioniert der Zeichenfolgenvergleich.

CJam (15 Bytes)

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

Online-Demo

Präparation

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

Für die gleiche Länge, aber eher in hässlichem Hack-Gebiet,

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

Sed, 40 Zeichen

(39 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

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

Eingabe: String, Ausgabe: unäre Zahl.

Probelauf:

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 Zeichen

(32 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

Wenn nachfolgende Leerzeichen in der Ausgabe zulässig sind.

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

Eingabe: String, Ausgabe: unäre Zahl.

Probelauf:

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      

Hexagonie , 61 Bytes

Edit : Danke @Martin Ender ♦, dass du mir 1 Byte vom wunderbaren -1-Trick erspart hast!

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

Probieren Sie es online aus, um Testfälle zu überprüfen!

Die folgenden Bilder werden nicht geändert, aber der Fluss ist im Grunde der gleiche. Beachten Sie auch, dass dies zurückgegeben wird, -1wenn die Eingabe kein Array ist (dh ohne[] ).

Ich habe viele No-Ops im Hexagon ... ich denke, es kann definitiv mehr Golf gespielt werden.

Erläuterung

Kurz gesagt, fügt es , -1wenn ein begegnet [und fügt hinzu , 1wenn ein begegnet ]. Schließlich druckt es das Maximum aus, das es hat.

Führen Sie Test Case 5 aus, um dessen Verhalten bei Ausführung entlang der Zeichenfolge zu überprüfen [1, [[3]], [5, 6], [[[[8]]]], 1]:

Es beginnt am Anfang und wird an der W-Ecke eingegeben:

Da gibt es noch Eingaben (nicht das Nullzeichen \0 oder EOL), wird der Zeilenumbruch nach oben ausgeführt und der purpurrote Pfad gestartet.

Hier ist, was passiert, wenn von dort bis süß >< :

,Liest [in den Puffer {und Zsetzt die Konstante Z auf 90. 'Wechselt zu Diff und -berechnet die Differenz. Für [und ]der Unterschied wird 1und sein 3. Für Zahlen und Leerzeichen und Kommas ist es negativ.

Dann laufen wir (zweimal (einmal am Ende des purpurroten Pfades, einmal am Anfang nach dem Umwickeln des grünen Pfades), um zu bekommen -1und 1resp für [und ]. Hier ändern wir die Benennung von Diffzu Value. Fügen Sie diesen Wert der Tiefe hinzu. (Früher habe ich dafür Z&gesorgt, dass es den rechten Nachbarn kopiert). Dann berechnen wir lastMin - Depthund erhalten eine Zahl auf der Memory-Kante minLR.

Dann wenden wir &(am Ende des grünen Pfads) an minLR: Wenn die Zahl <= 0 ist, wird der linke Wert kopiert (d. HlastMin - Depth <= 0 => lastMin <= Depth ), andernfalls nimmt sie den rechten Wert an.

Wir springen auf den horizontalen blauen Pfad und sehen Z&erneut, welcher den kopiert minLR. Dann haben wir "&und eine Kopie der berechneten min. Die Klammern werden als ausgeglichen angenommen, daher muss die min <= 0 sein. Nach dem Wickeln geht der blaue Pfad nach links und trifft (, wodurch die Kopie 1kleiner als die reale Minute ist. Bei erneuter Verwendung von -haben wir eine weitere einmalige Kopie als Nachbar von Buffer erstellt:

Hinweis: copy wird umbenannt in1-off

Wenn der blaue Pfad trifft \und ein schönes "und< erwischt ihn zurück zur Hauptschleife fängt.

Wenn die Schleife trifft 1, ,oder oder andere Zahlen als Eingabe:

Der Diff wird negativ und wird für die nächste Eingabe in die Hauptschleife zurückgespiegelt.

Wenn alles die Hauptschleife durchlaufen hat, erreichen wir EOL, was Buffer macht -1und es geht schließlich bis zum unteren Rand:

'Bewegt den MP zu 1-off copyund )inkrementiert ihn, und mit ~Negation erhält er den korrekten Wert für die maximale Tiefe, mit dem gedruckt wird!

Und die Geschichte endet mit einem @.

Ich denke, ich muss es etwas komplizierter haben. Wenn ich nur "zurückgehen" und "drucken" müsste, ohne zu erhöhen und zu negieren, hätte ich gut 2 Bytes gespart, ohne das volle Hexagon zu verwenden.

Vielen Dank an Timwi für Esoteric IDE und Hexagony Colorer !

Brainfuck, 48 Bytes

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

Formatiert:

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

Übernimmt die Eingabe wie formatiert (1, ((3)), (5, 6), ((((8)))), 1)und gibt einen Bytewert aus .

Probieren Sie es online aus.

Hiermit wird die Tiefe nach Speicherort gespeichert, wobei der Zeiger nach rechts (und links bewegt )und andere Zeichen ignoriert werden. Besuchte Zellen sind mit einem 1Flag gekennzeichnet, sodass sich am Ende der Hauptschleife depth + 1rechts neben der aktuellen Zelle ein Flag befindet . Diese werden dann hinzugefügt, um das Endergebnis auszudrucken.

Eine vorherige 69-Byte-Lösung mit einem anderen Ansatz:

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

In dieser Version werden die Tiefe und die maximale Tiefe explizit in Zellen gespeichert.

Pyth, 15 13 Bytes

-2 Bytes von @Maltysen

eSm-F/Ld`Y._z

Zählt die Differenz zwischen den kumulativen Zählern [und ]und nimmt das Maximum an. Yist das leere Array, und seine Zeichenfolgendarstellung ( `) ist günstig [].

Probieren Sie es hier aus .

CJam, 19 22 23 Bytes

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

Ähnliche Idee zu meiner MATL-Antwort.

Vielen Dank an Peter Taylor für das Entfernen von 3 Bytes

Probieren Sie es hier aus

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 Bytes

32 plus zwei für -p

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

Gestohlen von Digital - Trauma ‚s Retina Antwort ... die 26% kürzer als dieser ist.:-)

Oder gleichermaßen:

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

Ruby, 51 Zeichen

(Gestartet als Verbesserungsvorschlag für Doorknob ‚s Ruby - Antwort , aber am Ende anders. Also hat er es als separate Antwort geschrieben. Upvotes für die Tiefenzählung Idee ( ?\\<=>$&za aus '] ['.index(c)) geht auf die ursprüngliche Antwort.)

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

Eingabe: String, Ausgabe: Zahl.

Probelauf:

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 Bytes

Die Schließung:

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

Benötigt ein Argument, zB:

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

Erläuterung:

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

Mein Algorithmus wurde nach Inspiration von Luis Mendos CJam-Antwort überarbeitet und 5 Bytes gespart!

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

Probieren Sie es hier aus!

Erläuterung

Im Wesentlichen führt dieser Code eine laufende Summe mit +1 für jeden [und -1 für jeden durch ], verfolgt den erreichten Maximalwert und gibt dieses Maximum am Ende aus. Das Schleifen wird durch die toroidale Natur von Minkolangs Codebox gehandhabt.

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 Zeichen

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

Parameter: Array, Rückgabe: Zahl.

Probelauf:

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

Nicht golfen

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

Das CONNECT BY erstellt eine Zeile pro Zeichen in der Eingabezeichenfolge.

Der SUBSTR isoliert das der Zeilennummer entsprechende Zeichen.

Der DECODE übersetzt jedes '[' zu 1, jedes ']' zu -1 und jedes andere Zeichen zu 0.

Die analytische SUMME summiert jeweils 1, -1 und 0 aus den vorhergehenden Zeilen, einschließlich der aktuellen Zeile.

Die MAX-Summe ist die Tiefe.

Java 8, 95

Dies ist ein Lambda-Ausdruck für a ToIntFunction<String>. Die Eingabe wird Stringim OP-Beispielformat als übernommen.

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

ziemlich geradeaus. Teilen Sie die Zeichenfolge mit [als Trennzeichen. Inkrementieren Sie für jeden von ihnen den Zähler eund vergleichen Sie ihn mit dem Zähler d, wobei der größere von ihnen erhalten bleibt d. Teilen Sie dann die Zeichenfolge der aktuellen Iteration auf, indem Sie ]diesmal als Trennzeichen verwenden, und subtrahieren Sie die Anzahl der zusätzlichen Teilungen von e.