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 código de golf .

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

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

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 .

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.

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.

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.

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>

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

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 .

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!

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

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.

Mathematica, 18 bytes

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

Mathematica, 27 20 bytes

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

Función recursiva simple.

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.

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

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

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.

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-

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      

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:

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.

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:

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:

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:

'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 !

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.

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í .

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

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

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

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
}

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

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 

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.

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.