Determinar la profundidad de una matriz.

32

Un desafío simple para su lunes por la noche (bueno, o martes por la mañana en la otra mitad del mundo ...)

Se le da como entrada una matriz anidada, potencialmente desigual, de enteros positivos:

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

Su tarea es determinar su profundidad, que es la mayor profundidad de anidamiento de cualquier número entero en la lista. En este caso, la profundidad de 11es 6, que es mayor.

Puede suponer que ninguna de las matrices estará vacía.

Puede escribir un programa o función, tomando la entrada a través de STDIN (o la alternativa más cercana), argumento de línea de comando o argumento de función y generando el resultado a través de STDOUT (o la alternativa más cercana), el valor de retorno de la función o el parámetro de función (out).

La entrada puede tomarse en cualquier lista conveniente o formato de cadena que admita matrices no rectangulares (con matrices anidadas de diferentes profundidades), siempre que la información real no esté preprocesada.

No debe utilizar ninguna función integrada relacionada con la forma de las matrices (incluidas las integradas que resuelven este desafío, que le dan las dimensiones de una matriz anidada). La única excepción a esto es obtener la longitud de una matriz.

Aplican reglas estándar de .

Casos de prueba

[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
Martin Ender
fuente
2
Después de la discusión en el chat, he decidido permitir la integración de longitud, porque algunos idiomas requieren que se repitan en una matriz limpiamente.
Martin Ender
2
Solo para educación general: es la primitiva incorporada de APL para exactamente esto .
Adám
@ MartinBüttner Me he encontrado con un pequeño problema. Comencé a hacer esto en java, inestablemente cuando probaba entradas, las comas están causando que las entradas se dividan en múltiples argumentos de línea de comando en lugar de uno. ¿Puedo usar el carácter de escape \ en las entradas? EDITAR: no importa solo lo intenté así. Eso ni siquiera funciona. Maldición, ¿no puedo usar args CMD?
Ashwin Gupta
@AshwinGupta, ¿no puedes ajustar el argumento de la línea de comando entre comillas? También puede leer la entrada de STDIN o enviar una función que tome un objeto de matriz real como parámetro.
Martin Ender
@ MartinBüttner oh, no sabía eso de las citas, lo probaré. Actualmente solo estoy usando Scanner. (System.in). ¿Creo que es una forma de STDIN?
Ashwin Gupta

Respuestas:

20

K, 4 bytes

#,/\

En K, ,/unirá todos los elementos de una lista. El idioma común ,//itera a un punto fijo, allanando por completo una lista anidada arbitrariamente. ,/\iterará a un punto fijo de manera similar, pero reunirá una lista de resultados intermedios. Al contar cuántos resultados intermedios visitamos antes de llegar al punto fijo ( #), obtenemos la respuesta que queremos: la profundidad máxima de anidación.

"Conteo de unión sobre exploración de punto fijo".

En acción:

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

Retina , 10

  • Guardado 1 byte gracias a @ ӍѲꝆΛҐӍΛПҒЦꝆ
  • Ahorró 14 bytes adicionales gracias a @ MartinBüttner
+ `\ w |} {

{

Aquí el formato de entrada es un poco artificial: los _caracteres se usan para los separadores de listas, por lo que una entrada se vería así{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

  • Etapa 1: eliminar repetidamente }{y todos los demás \wpersonajes. Esto tiene el efecto de a) hacer que todas las listas en todos los niveles consistan en un solo elemento yb) eliminar todos los caracteres no estructurales de la lista.
  • Etapa 2 - cuenta restante {. Esto proporciona el nivel más profundo de anidación.

Pruébalo en línea.


Si eso es demasiado, la respuesta anterior fue:

Retina , 13

Asume que las listas están contenidas entre llaves {}.

+ `[^} {] |} {

{

Pruébalo en línea .

Trauma digital
fuente
1
Su código se puede acortar a 13 bytes (11 si estira un poco el formato de entrada). Avísame si quieres una pista. :) (Realmente no quiero publicarlo yo mismo, ya que es prácticamente la misma solución.)
Martin Ender
Son dos cosas a) Puede guardar un byte más o menos modificando ligeramente el formato de entrada. b) Puede guardar muchos bytes independientemente de eso ... ¿puede encontrar una solución más corta (y mucho más simple) si intenta no manejar múltiples casos de prueba en una sola ejecución?
Martin Ender
Ni siquiera pensé en eso. Esa cantidad de byte guardada entonces. Mi cambio al formato de entrada habría sido aún más débil. Con respecto a b) ¿recuerda cuál fue el primer y más simple modo de operación de Retina?
Martin Ender
1
Sí. Sin embargo, mi a) se refería a eliminar espacios de la entrada. Y luego puede guardar dos bytes más usando en _lugar de, ,pero eso podría ser un poco exagerado.
Martin Ender
@ MartinBüttner ¡Buena idea! De acuerdo: los _separadores pueden ser demasiado artificiales. Así que dejo ambas versiones en la respuesta
Digital Trauma
12

Python 2, 33 bytes

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

Define recursivamente la profundidad diciendo que la profundidad de un número es 0 y que la profundidad de una lista es uno más que la profundidad máxima de sus elementos. El número frente a la lista se verifica comparándolo con el diccionario vacío {}, que está por encima de los números pero debajo de las listas en el ordenamiento arbitrario de Python 2 de los tipos incorporados.

xnor
fuente
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
6

Pyth - 11 10 7 bytes

1 bytes guardados gracias a @Dennis

4 bytes guardados gracias a @Thomas Kwa

eU.usNQ

Pruébelo en línea aquí .

Sigue sumando la matriz hasta que deja de cambiar, lo que significa que es solo un número, lo hace de forma acumulativa para guardar todos los resultados intermedios y obtiene longitud haciendo un urange con la misma longitud que la lista y tomando el último elemento.

Maltysen
fuente
m!!dpuede llegar a ser &R1.
Dennis
@Dennis genial, eso es inteligente
Maltysen
@ThomasKwa lno está permitido en OP.
Maltysen
@ThomasKwa que es realmente inteligente, ¡gracias!
Maltysen
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
6

Haskell, 43 bytes

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

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

Haskell no tiene listas mixtas ( Integermezcladas con List of Integer), por lo que no puedo explotar algunas funciones de detección de listas y tengo que analizar la cadena.

Estoy comenzando por la derecha con 0y sumo 1 por cada ], reste 1 por cada [y mantenga el valor de lo contrario. scanrmantiene todos los resultados intermedios, por lo que maximumpuede hacer su trabajo.

nimi
fuente
5

JavaScript (ES6), 35 bytes

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

Explicación

Función recursiva que devuelve la profundidad máxima de una matriz, o 0si se pasa un número.

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>

usuario81655
fuente
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
4

MATL , 11 14 15 bytes

'}{'!=dYsX>

Las llaves se usan en MATL para este tipo de matrices. De todos modos, la entrada se toma y procesa como una cadena, por lo que los corchetes podrían usarse igualmente, modificando los dos caracteres en el código.

Pruébalo en línea!

          % 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
Luis Mendo
fuente
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
4

Octava, 29 bytes

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

Se asigna [a 1 y ]a -1, luego toma el máximo de la suma acumulativa.

La entrada es una cadena de la forma

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

Ejecución de muestra en ideone .

cubilete
fuente
En caso de utilizar {, }? La octava equivalente a las matrices en el OP son las matrices de celdas, creo
Luis Mendo
@LuisMendo No, porque son 2 bytes adicionales :) Además, dado que en realidad nunca creo la matriz, simplemente analizo la cadena de entrada, no creo que importe. Pero me has recordado agregar la entrada esperada a mi respuesta.
vaso de precipitados
¡Cierto! Código ASCII más largo
Luis Mendo,
@LuisMendo En realidad, 1 byte más. Esa segunda comparación solo necesita ser mayor que '9'. Pero tienes la idea: D
vaso
4

Julia, 55 26 bytes

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

Esta es una función recursiva que acepta una matriz unidimensional con contenido de tipo Anyy devuelve un entero. Al pasar una matriz a la función, prefije todos los corchetes con Any, es decir f(Any[1,Any[2,3]]).

El enfoque es bastante simple. Para una entrada a , multiplicamos a por 0 y verificamos si el resultado es el escalar 0. Si no, sabemos que a es una matriz, por lo que aplicamos la función a cada elemento de a , tomamos el máximo y sumamos 1.

¡Ahorró 29 bytes gracias a Dennis!

Alex A.
fuente
2
Dat golf. <filler>
El'endia Starman
3

Ruby, 53 bytes

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

Entrada de STDIN, salida a 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
Pomo de la puerta
fuente
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
3

Jalea, 10 7 bytes

¬;/SпL

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Actualizar

Mientras escribía esta respuesta, noté que Jelly se comporta de manera bastante extraña para las listas irregulares, porque calculé la profundidad de una lista como el mínimo incrementado de profundidades de sus elementos.

Esto se ha abordado en la última versión, por lo que el siguiente código ( 6 bytes ) funcionaría ahora.

¬SSпL

Esto suma las filas de la matriz en lugar de concatenarlas.

Dennis
fuente
Presumiblemente, ¿ ŒḊes más nuevo que el desafío?
caird coinheringaahing
No debe utilizar ninguna función integrada relacionada con la forma de las matrices (incluidas las integradas que resuelven este desafío, que le dan las dimensiones de una matriz anidada).
Dennis
3

Mathematica, 18 bytes

Max@#+1&//@(0#-1)&
alephalpha
fuente
¿Podría explicarlo, por favor?
skan
3

Mathematica, 27 20 bytes

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

Función recursiva simple.

LegionMammal978
fuente
Es posible anular el If, ahorrando 7 bytes. (Avísame si quieres una pista.)
Martin Ender
@ MartinBüttner Me rindo ... Una Replacesolución basada en al menos es tan larga como esta ...
LegionMammal978
1
Mapde ping más de un número entero es un no-op: Max[#0/@#]+1&[0#]-1&. El -1también puede ir dentro de la llamada interna como ...&[0#-1]&.
Martin Ender
3

PHP, 61 bytes

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

función recursiva que se utiliza a sí misma como una función de mapeo para reemplazar cada elemento con su profundidad.

Tito
fuente
Acabo de notar: Lo mismo en JS tiene solo 35 bytes. Sigue siendo bonita en php.
Tito
Bien, me ganaste. Pero actualicé la mía y te
golpeé
3

PHP, 84 72 64 63 60 bytes

Nota: requiere PHP 7 para el operador de comparación combinado. También usa la codificación IBM-850

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

Corre así:

php -r 'for(;$c=$argv[1][$i++];)$c>A&&$t=max($t,$z+=~ú<=>$c);echo$t;' "[1, [[3]], [5, 6], [[[[8]]]], 1]"
  • Ahorró 12 bytes simplemente contando llaves de la representación de cadena en su lugar
  • Ahorró 8 bytes al simplificar las comparaciones de cadenas y al usar el número ordinal del carácter en caso de [y]
  • Salvó un byte al no enviarlo $ia un int. Las compensaciones de cadena se convierten a un int implícitamente
  • Se guardaron 3 bytes mediante el uso del operador de comparación combinado en lugar del número ordinal
aross
fuente
Buena idea, gran golf! Mira el mío .
Titus
2

C, 98 69 bytes

29 bytes de descuento gracias @DigitalTrauma !!

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

Toma una cadena como entrada y devuelve el resultado como entero.

Ejemplo en vivo en: http://ideone.com/IC23Bc

remoto
fuente
2

Python 3, 42 39 bytes

-3 bytes gracias a Sp3000

Esto es esencialmente un puerto de la solución Python 2 de xnor :

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

Desafortunadamente, [] > {}devuelve un unorderable typeserror, por lo que ese truco inteligente particular de xnor no se puede usar. En su lugar, -0123456789son más bajos en valor ASCII que A, que es más bajo que [], por lo tanto, la comparación de cadenas funciona.

El'endia Starman
fuente
2

CJam (15 bytes)

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

Demostración en línea

Disección

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

Por la misma longitud pero bastante más en territorio de hack feo,

q'[,-{:~_}h],2-
Peter Taylor
fuente
s/ugly/beautiful/
Dennis
@ Dennis, me refería específicamente al uso de '[,-quitar la cadena [], lo que depende de que el contenido sea limitado. El enfoque que aplana funciona independientemente del contenido de la matriz.
Peter Taylor
El segundo es más bonito. El primero tiene dos tipos de llaves no coincidentes
Cyoce,
2

Sed, 40 caracteres

(Código de 39 caracteres + opción de línea de comando de 1 carácter).

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

Entrada: cadena, salida: número unario.

Ejecución de muestra:

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 caracteres

(Código de 32 caracteres + opción de línea de comando de 1 carácter).

Si se permiten espacios finales en la salida.

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

Entrada: cadena, salida: número unario.

Ejecución de muestra:

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      
hombre trabajando
fuente
2

Hexagonía , 61 bytes.

Editar : ¡Gracias @Martin Ender ♦ por salvarme 1 byte del maravilloso truco -1!

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

¡Pruébelo en línea para verificar casos de prueba!

Las imágenes a continuación no se modifican, pero el flujo es básicamente el mismo. También tenga en cuenta que esto volverá -1si la entrada no es una matriz (es decir, sin []).

Tengo un montón de no-operaciones dentro del Hexágono ... Supongo que definitivamente se puede jugar más.

Explicación

En resumen, agrega -1cuando encuentra a [y agrega 1cuando encuentra a ]. Finalmente imprime el máximo que tiene.

Ejecutemos el caso de prueba 5 para ver su comportamiento cuando se ejecuta a lo largo de la cadena [1, [[3]], [5, 6], [[[[8]]]], 1]:

Comienza al principio y toma su entrada en la esquina W:

Soportes

Como todavía hay entrada (no el carácter nulo \0o EOL), se ajusta a la parte superior e inicia la ruta carmesí.

Esto es lo que sucede cuando desde allí hasta lindo ><:

,lee [en la memoria tampón, y {y Zestablece el Z constante para ser 90. 'mueve a Dif y -calcula la diferencia. Para [y ]la diferencia será 1y 3respectivamente. Para números, espacios y comas será negativo.

M1 M2

Luego corremos (dos veces (una al final del camino carmesí, una al comienzo después de envolver en el camino verde) para obtener -1y 1resp para [y ]. Aquí cambiamos el nombre de Diffa Value. Agregue este valor a la profundidad. (Solía Z&asegurarme de que copiara al vecino correcto). Luego calculamos lastMin - Depthy obtuvimos un número en el borde de la memoria minLR.

Luego aplicamos &(al final del camino verde) a minLR: Si el número es <= 0, copia el valor izquierdo (es decir lastMin - Depth <= 0 => lastMin <= Depth), de lo contrario toma el valor correcto.

Envolvemos el camino azul horizontal y vemos de Z&nuevo qué copia el minLR. Luego nosotros "&e hicimos una copia del min calculado. Se supone que los corchetes están equilibrados, por lo que el mínimo debe ser <= 0. Después de ajustar, el camino azul va a la izquierda y golpea (, haciendo que la copia sea 1menor que el mínimo real. Reutilizando el -, creamos una copia única más como vecino de Buffer:

M3

Nota: copyse renombra como1-off

Cuando el camino azul golpea \y obtiene un bonito "y lo <atrapa de vuelta al circuito principal.

Cuando los éxitos de bucle 1, ,o u otros números como entrada:

otrosM4

El Diff se volverá negativo y se reflejará nuevamente en el bucle principal para la próxima entrada.

Cuando todo ha pasado por el bucle principal, llegamos a EOL que hace Buffer -1y finalmente va al borde inferior:

M5

'mueve el MP hacia el 1-off copyy lo )incrementa, y con la ~negación obtuvo el valor correcto de Profundidad Máxima que se imprime con!

Y la historia termina con a @.

Supongo que debo haber complicado un poco las cosas. Si solo hubiera tenido que "retroceder" e "imprimir" sin incrementar y negar, habría guardado bien 2 bytes sin usar el hexágono completo.

¡ Muchas gracias a Timwi por IDE Esotérico y Hexagony Colorer !

Sunny Pun
fuente
Puede guardar un byte haciendo uso de -1desde ,cambiando la última fila a: @!-".(aunque estoy de acuerdo en que probablemente sea posible recortar mucho más o incluso ajustar esto en la longitud lateral 4 con algo de reestructuración).
Martin Ender
¡No he pensado en usar el -1! Se editará una vez que tenga mi computadora. Si la temperatura está en el vecino izquierdo, habría ahorrado bastantes Zde usar Z&. Y debería haber mejores formas de iniciar el programa con el if implícito.
Sunny Pun
2

brainfuck, 48 bytes

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

Formateado:

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

Toma la entrada formateada como (1, ((3)), (5, 6), ((((8)))), 1)y emite un valor de byte .

Pruébalo en línea.

Esto almacena la profundidad por ubicación de memoria, moviendo el puntero hacia la derecha (y hacia la izquierda )e ignorando otros caracteres. Las celdas visitadas están marcadas con una 1bandera, por lo que al final del bucle principal habrá depth + 1banderas a la derecha de la celda actual. Estos se agregan para imprimir el resultado final.


Una solución anterior de 69 bytes que utiliza un enfoque diferente:

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

En esta versión, la profundidad y la profundidad máxima se almacenan explícitamente en celdas.

Mitch Schwartz
fuente
1

Pyth, 15 13 bytes

-2 bytes por @Maltysen

eSm-F/Ld`Y._z

Cuenta la diferencia entre los recuentos acumulativos de [y ], y toma el máximo. Yes la matriz vacía, y su representación de cadena ( `) es conveniente [].

Probarlo aquí .

lirtosiast
fuente
Las incorporaciones de longitud ahora están permitidas si esto ayuda.
Martin Ender
1

CJam, 19 22 23 bytes

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

Idea similar a mi respuesta MATL.

Gracias a Peter Taylor por eliminar 3 bytes

Pruébalo aquí

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
Luis Mendo
fuente
1

Perl 5, 34 bytes

32, más dos para -p

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

Robados de Digital Trauma 's Retina respuesta ... que es un 26% más corto que esto.:-)

O, igualmente:

{s&]\[|[^][]&&g&&redo}$_=y///c/2
msh210
fuente
@Cyoce, ¿por qué? ]no necesita escapar, excepto entre paréntesis.
msh210
@Cyoce, s&...&...&ges el operador de sustitución. Ver perldoc.perl.org/perlop.html
msh210
1

Ruby, 51 caracteres

(Comenzó como una sugerencia de mejora para la respuesta Ruby de Doorknob , pero terminó de manera diferente. Así que la publiqué como respuesta separada. Los votos a favor de la idea de contar en profundidad ( descendiendo de ) deberían ir a la respuesta original).?\\<=>$&'] ['.index(c)

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

Entrada: cadena, salida: número.

Ejecución de muestra:

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
hombre trabajando
fuente
1

Perl 6, 53 bytes

El cierre:

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

Necesita un argumento, por ejemplo:

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

Explicación:

{ 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
}
raiph
fuente
1

Minkolang 0.15 , 31 29 24 bytes

¡Revisé mi algoritmo inspirado por la respuesta CJam de Luis Mendo y ahorré 5 bytes!

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

Pruébalo aquí!

Explicación

Esencialmente, lo que hace este código es mantener un total acumulado con +1 para cada uno [y -1 para cada uno ], haciendo un seguimiento del valor máximo alcanzado, generando ese máximo al final. El bucle se maneja por la naturaleza toroidal de la caja de códigos de 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
El'endia Starman
fuente
1

Ruby, 41 caracteres

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

Parámetro: matriz, retorno: número.

Ejecución de muestra:

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 
hombre trabajando
fuente
1

Oracle SQL 11.2, 133 bytes

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

Sin golf

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 crea una fila por carácter en la cadena de entrada.

El SUBSTR aísla el carácter correspondiente al número de fila.

El DECODE traduce cada '[' a 1, cada ']' a -1 y todos los demás caracteres a 0.

El SUM analítico suma cada 1, -1 y 0 de las filas anteriores, incluida la fila actual;

Las sumas máximas son la profundidad.

Jeto
fuente
1

Java 8, 95

Esta es una expresión lambda para a ToIntFunction<String>. La entrada se toma como a Stringen el formato de ejemplos del OP.

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

bastante directo Divida la cadena usando [como delimitador. Para cada uno de ellos, incremente el contador ey compárelo con el contador d, manteniendo el más grande adentro d. Luego divida la cadena de la iteración actual usando ]como delimitador esta vez y reste el número de divisiones adicionales de e.

Jack munición
fuente