Una semplice sfida per il tuo lunedì sera (beh, o martedì mattina nell'altra metà del mondo ...)

Ti viene dato come input un array nidificato, potenzialmente irregolare, di numeri interi positivi:

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

Il tuo compito è determinare la sua profondità, che è la massima profondità di annidamento di qualsiasi numero intero nell'elenco. In questo caso, la profondità di 11è 6, che è la più grande.

Si può presumere che nessuno degli array sarà vuoto.

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

L'input può essere preso in qualsiasi elenco o formato stringa conveniente che supporti array non rettangolari (con array nidificati di diverse profondità), purché le informazioni effettive non siano preelaborate.

Non è necessario utilizzare alcun componente incorporato relativo alla forma degli array (inclusi quelli integrati che risolvono questa sfida, che consentono di ottenere le dimensioni di un array nidificato). L'unica eccezione a ciò è ottenere la lunghezza di un array.

Si applicano le regole standard del code-golf .

Casi test

[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

#,/\

In K, ,/si uniranno tutti gli elementi di un elenco. Il linguaggio comune ,//scorre in un punto fisso, appiattendo completamente un elenco nidificato arbitrariamente. ,/\eseguirà l'iterazione in un punto fisso in modo simile, ma raccoglierà un elenco di risultati intermedi. Contando quanti risultati intermedi visitiamo prima di raggiungere il punto fisso ( #), otteniamo la risposta che vogliamo: la massima profondità di annidamento.

Msgstr "Conteggio del join sulla scansione a virgola fissa".

In azione:

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

Retina , 10

• Salvato 1 byte grazie a @ ӍѲꝆΛҐӍΛПҒЦꝆ
• Risparmiato 14 byte extra grazie a @ MartinBüttner

+ `\ W |} {

{

Qui il formato di input è un po 'forzato: i _caratteri vengono utilizzati per i separatori di elenco, quindi un input sarebbe simile a questo{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Fase 1: rimuovi ripetutamente }{e tutti gli altri \wpersonaggi. Ciò ha l'effetto di a) rendere tutte le liste a tutti i livelli costituite da un solo elemento eb) rimuovere tutti i caratteri non di struttura strutturale.
• Fase 2: conteggio rimanente {. Questo dà il livello più profondo di nidificazione.

Provalo online.

Se è troppo lungo, la risposta precedente era:

Retina , 13

Gli elenchi dei presupposti sono contenuti tra parentesi graffe {}.

+ `[^} {] |} {

{

Provalo online .

Python 2, 33 byte

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

Definisce in modo ricorsivo la profondità dicendo che la profondità di un numero è 0 e la profondità di un elenco è una in più rispetto alla profondità massima dei suoi elementi. Elenco contro numero viene verificato confrontandolo con il dizionario vuoto {}, che cade sopra i numeri ma sotto gli elenchi sull'ordinamento arbitrario di tipi predefiniti di Python 2.

Pyth - 11 10 7 byte

1 byte salvato grazie a @Dennis

4 byte salvati grazie a @Thomas Kwa

eU.usNQ

Provalo online qui .

Continua a sommare l'array fino a quando non smette di cambiare, il che significa che è solo un numero, lo fa cumulativamente per salvare tutti i risultati intermedi e ottiene la lunghezza creando un urange con la stessa lunghezza dell'elenco e prendendo l'ultimo elemento.

Haskell, 43 byte

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

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

Haskell non ha liste miste ( Integermescolate con List of Integer), quindi non posso sfruttare alcune funzioni di rilevazione di liste e devo analizzare la stringa.

Sto iniziando a destra con 0e aggiungo 1 per ogni ], sottrai 1 per ogni [e mantieni il valore in caso contrario. scanrmantiene tutti i risultati intermedi, quindi maximumpuò fare il suo lavoro.

JavaScript (ES6), 35 byte

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

Spiegazione

Funzione ricorsiva che restituisce la profondità massima di un array o 0se viene passato un numero.

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>

Le parentesi graffe sono utilizzate in MATL per questo tipo di array. Ad ogni modo, l'input viene preso ed elaborato come una stringa, quindi le parentesi quadre potrebbero essere ugualmente utilizzate, modificando i due caratteri nel codice.

Provalo 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

Ottava, 29 byte

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

Mappe [a 1 e] su -1, quindi prende il massimo della somma cumulativa.

L'input è una stringa del modulo

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

Esempio eseguito su ideone .

Julia, 55 26 byte

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

Questa è una funzione ricorsiva che accetta un array unidimensionale con contenuti di tipo Anye restituisce un numero intero. Quando si passa un array alla funzione, aggiungere il prefisso a tutte le parentesi Any, ad es f(Any[1,Any[2,3]]).

L'approccio è piuttosto semplice. Per un input a , moltiplichiamo a per 0 e controlliamo se il risultato è lo scalare 0. In caso contrario, sappiamo che a è un array, quindi applichiamo la funzione a ciascun elemento di a , prendiamo il massimo e aggiungiamo 1.

Risparmiato 29 byte grazie a Dennis!

Rubino, 53 byte

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

Ingresso da STDIN, uscita 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

Gelatina, 10 7 byte

¬;/SпL

Provalo online! o verifica tutti i casi di test .

Come funziona

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

Aggiornare

Mentre scrivevo questa risposta, ho notato che Jelly si comporta in modo piuttosto strano per gli elenchi irregolari, perché ho calcolato la profondità di un elenco come incrementata minimo delle profondità dei suoi elementi.

Questo problema è stato risolto nell'ultima versione, quindi il seguente codice ( 6 byte ) funzionerebbe ora.

¬SSпL

Ciò somma le righe dell'array invece di concatenarle.

Mathematica, 18 byte

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

Mathematica, 27 20 byte

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

Semplice funzione ricorsiva.

PHP, 61 byte

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

funzione ricorsiva che si utilizza come una funzione di mappatura per sostituire ogni elemento con la sua profondità.

PHP, 84 72 64 63 60 byte

Nota: richiede PHP 7 per l'operatore di confronto combinato. Utilizza anche la codifica IBM-850

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

Esegui in questo modo:

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

• Hai salvato 12 byte contando semplicemente le parentesi graffe della rappresentazione della stringa
• Salvato 8 byte semplificando il confronto delle stringhe e utilizzando il numero ordinale del carattere in caso di [ e]
• Salvato un byte non eseguendo il casting $iin un int. Gli offset di stringa vengono espressi implicitamente in un int
• Salvato 3 byte utilizzando l'operatore di confronto combinato anziché il numero ordinale

C, 98 69 byte

29 byte di sconto grazie @DigitalTrauma !!

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

Accetta una stringa come input e restituisce il risultato come intero.

Esempio live in: http://ideone.com/IC23Bc

Python 3, 42 39 byte

-3 byte grazie a Sp3000

Questa è essenzialmente una porta della soluzione Python 2 di xnor :

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

Sfortunatamente, [] > {}restituisce un unorderable typeserrore, quindi non è possibile utilizzare quel trucco intelligente di xnor. Al suo posto, -0123456789sono inferiori nel valore ASCII di A, che è inferiore a [], quindi il confronto tra stringhe funziona.

CJam (15 byte)

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

Demo online

Dissezione

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

Per la stessa lunghezza ma un po 'di più nel brutto territorio hack,

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

Sed, 40 personaggi

(Codice di 39 caratteri + opzione della riga di comando di 1 carattere.)

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

Input: stringa, output: numero unario.

Esecuzione di esempio:

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 personaggi

(Codice 32 caratteri + opzione riga comandi 1 carattere.)

Se sono consentiti spazi finali nell'output.

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

Input: stringa, output: numero unario.

Esecuzione di esempio:

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      

Esagonia , 61 byte

Modifica : Grazie @Martin Ender ♦ per avermi salvato 1 byte dal meraviglioso trucco -1!

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

Provalo online per verificare i casi di test!

Le immagini sottostanti non vengono modificate ma il flusso è sostanzialmente lo stesso. Si noti inoltre che questo ritornerà -1se l'input non è un array (ovvero senza[] ).

Ho un sacco di no-op all'interno di Hexagon ... Immagino che possa sicuramente essere giocato di più.

Spiegazione

In breve, aggiunge -1quando incontra a [e aggiunge 1quando incontra a ]. Finalmente stampa il massimo che ha.

Eseguiamo il Test Case 5 per vedere il suo comportamento quando corre lungo la String [1, [[3]], [5, 6], [[[[8]]]], 1]:

Inizia all'inizio e prende il suo input nell'angolo W:

Dato che c'è ancora input (non il carattere null \0 o EOL), si sposta all'inizio e inizia il percorso cremisi.

Ecco cosa succede quando da lì fino a quando carino ><:

,legge [nel buffer {e Zimposta la costante Z su 90. 'passa a Diff e -calcola la differenza. Per [e ]la differenza sarà 1e 3rispettivamente. Per numeri, spazi e virgole sarà negativo.

Quindi corriamo (due volte (una volta alla fine del percorso cremisi, uno all'inizio dopo aver avvolto il percorso verde) per ottenere -1e 1rispettare [e ]. Qui cambiamo la denominazione di Diffa Value. Aggiungi questo valore alla profondità. (Mi Z&assicuravo che copiasse il vicino giusto). Quindi calcoliamo lastMin - Depthe otteniamo un numero sul bordo della memoria minLR.

Quindi applichiamo &(alla fine del percorso verde) a minLR: Se il numero è <= 0, copia il valore a sinistra (eslastMin - Depth <= 0 => lastMin <= Depth ), altrimenti prende il valore giusto.

Passiamo al percorso orizzontale blu e vediamo di Z&nuovo quale copia di minLR. Quindi abbiamo "&creato una copia del min calcolato. Si presume che le parentesi siano bilanciate, quindi il minimo deve essere <= 0. Dopo aver eseguito il wrapping, il percorso blu va a sinistra e preme (, rendendo la copia 1inferiore al minimo reale. Riutilizzando il -, abbiamo creato un'altra copia 1-off come un vicino di buffer:

Nota: copyviene rinominato come1-off

Quando il percorso blu colpisce \e diventa bello "e <lo riporta al circuito principale.

Quando il ciclo colpisce 1, ,o o altri numeri come input:

Il Diff diventerà negativo e verrà riflesso nel loop principale per il prossimo input.

Quando tutto è passato attraverso il ciclo principale, raggiungiamo EOL che rende Buffer -1e infine va al margine inferiore:

'sposta il MP su 1-off copye lo )incrementa, e con ~negazione ottiene il valore di Profondità massima corretto con cui viene stampato!

E la storia finisce con a @.

Immagino di dover complicare un po 'le cose. Se avessi dovuto solo "tornare indietro" e "stampare" senza incrementare e negare, avrei salvato bene 2 byte senza usare l'esagono completo.

Grazie mille a Timwi per Esoteric IDE e Hexagony Colorer !

Brainfuck, 48 byte

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

formattato:

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

Accetta input formattati come (1, ((3)), (5, 6), ((((8)))), 1)e genera un valore in byte .

Provalo online.

Ciò memorizza la profondità in base alla posizione della memoria, spostando il puntatore verso destra (e verso sinistra )e ignorando altri caratteri. Le celle visitate sono contrassegnate da un 1flag, quindi alla fine del loop principale ci saranno depth + 1flag a destra della cella corrente. Questi vengono quindi aggiunti per stampare il risultato finale.

Una precedente soluzione a 69 byte con un approccio diverso:

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

In questa versione, la profondità e la profondità massima sono memorizzate esplicitamente nelle celle.

Pyth, 15 13 byte

-2 byte di @Maltysen

eSm-F/Ld`Y._z

Conta la differenza tra i conteggi cumulativi di [e ]e prende il massimo. Yè l'array vuoto e la sua rappresentazione di stringa ( `) è conveniente [].

Provalo qui .

CJam, 19 22 23 byte

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

Idea simile alla mia risposta MATL.

Grazie a Peter Taylor per aver rimosso 3 byte

Provalo qui

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, più due per -p

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

Stolen da trauma digitale 's Retina risposta ... che è il 26% più breve di questo.:-)

O ugualmente:

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

Rubino, 51 caratteri

(Iniziato come suggerimento di miglioramento per la risposta di Ruby di Doorknob , ma è finito in modo diverso. Così l'ho pubblicato come risposta separata. I voti per l'idea del conteggio di profondità ( , decrescente da ) dovrebbero andare alla risposta originale.)?\\<=>$&'] ['.index(c)

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

Input: stringa, output: numero.

Esecuzione di esempio:

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

La chiusura:

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

Ha bisogno di un argomento, ad esempio:

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

Spiegazione:

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

Revisionato il mio algoritmo su ispirazione della risposta CJam di Luis Mendo e salvato 5 byte!

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

Provalo qui!

Spiegazione

In sostanza, ciò che questo codice fa è mantenere un totale parziale con +1 per ciascuno [e -1 per ciascuno ], tenendo traccia del valore massimo raggiunto, producendo quel massimo alla fine. Il looping è gestito dalla natura toroidale della codebox di 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

Rubino, 41 caratteri

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

Parametro: array, return: number.

Esecuzione di esempio:

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

Un-golfed

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 riga per carattere nella stringa di input.

SUBSTR isola il carattere corrispondente al numero di riga.

DECODE traduce ogni '[' in 1, ciascuno ']' in -1 e ogni altro carattere in 0.

La SOMMA analitica somma ogni 1, -1 e 0 dalle righe precedenti, inclusa la riga corrente;

La somma massima è la profondità.

Java 8, 95

Questa è un'espressione lambda per a ToIntFunction<String>. L'input viene preso come a Stringnel formato di esempio del PO.

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

abbastanza diretto. Dividi la stringa usando [come delimitatore. Per ognuno di essi, incrementa il contatore ee confrontalo con il contatore d, mantenendo il più grande dentro d. Quindi dividere la stringa dell'iterazione corrente usando ]questa volta come delimitatore e sottrarre il numero di divisioni extra da e.