Un défi simple pour votre lundi soir (enfin, ou mardi matin dans l'autre moitié du monde ...)

On vous donne en entrée un tableau imbriqué, potentiellement irrégulier d'entiers positifs:

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

Votre tâche consiste à déterminer sa profondeur, qui est la plus grande profondeur d'imbrication de tout entier dans la liste. Dans ce cas, la profondeur de 11est 6, qui est la plus grande.

Vous pouvez supposer qu'aucun des tableaux ne sera vide.

Vous pouvez écrire un programme ou une fonction en prenant l’entrée via STDIN (ou l’alternative la plus proche), un argument de ligne de commande ou une argumentation de fonction et en générant le résultat via STDOUT (ou l’alternative la plus proche), une valeur de retour de fonction ou un paramètre de fonction (out).

L'entrée peut être prise dans n'importe quel format de liste ou de chaîne qui prend en charge les tableaux non rectangulaires (avec des tableaux imbriqués de différentes profondeurs), tant que les informations réelles ne sont pas prétraitées.

Vous ne devez pas utiliser de modules intégrés liés à la forme des tableaux (y compris les modules intégrés qui résolvent ce défi, qui vous donnent les dimensions d'un tableau imbriqué). La seule exception à cela est la longueur d'un tableau.

Les règles de code-golf standard s'appliquent.

Cas de 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 octets

#,/\

En K, ,/rejoindra tous les éléments d'une liste. L'idiome commun ,//parcourt un point fixe, aplatissant complètement une liste imbriquée arbitrairement. ,/\itérera jusqu'à un point fixe de la même manière, mais rassemblera une liste de résultats intermédiaires. En comptant le nombre de résultats intermédiaires que nous visitons avant d'atteindre le point fixe ( #), nous obtenons la réponse que nous voulons: la profondeur d'imbrication maximale.

Msgstr "Nombre de jointures sur scan à virgule fixe".

En action:

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

Rétine , 10

• 1 octet enregistré grâce à @ ӍѲꝆΛҐӍΛПҒЦꝆ
• 14 octets supplémentaires enregistrés grâce à @ MartinBüttner

+ `\ w |} {

{

Ici, le format d'entrée est un peu artificiel - les _caractères sont utilisés pour les séparateurs de liste, donc une entrée ressemblerait à ceci{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Étape 1 - supprimer à plusieurs reprises }{et tous les autres \wpersonnages. Cela a pour effet a) de faire en sorte que toutes les listes à tous les niveaux soient constituées d'un seul élément et b) de supprimer tous les caractères structurels non liés à une liste.
• Étape 2 - compte restant {. Cela donne le niveau d'imbrication le plus profond.

Essayez-le en ligne.

Si c'est trop difficile, la réponse précédente était:

Rétine , 13

Suppose que les listes sont contenues entre accolades {}.

+ `[^} {] |} {

{

Essayez-le en ligne .

Python 2, 33 octets

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

Définit récursivement la profondeur en disant que la profondeur d'un nombre est 0 et que la profondeur d'une liste est supérieure de un à la profondeur maximale de ses éléments. Le nombre par rapport à la liste est vérifié en comparant au dictionnaire vide {}, qui tombe au-dessus des nombres mais en dessous des listes sur l'ordre arbitraire de Python 2 des types intégrés.

Pyth - 11 10 7 octets

1 octets économisés grâce à @Dennis

4 octets économisés grâce à @Thomas Kwa

eU.usNQ

Essayez-le en ligne ici .

Continue à additionner le tableau jusqu'à ce qu'il cesse de changer, ce qui signifie que ce n'est qu'un nombre, le fait cumulativement pour enregistrer tous les résultats intermédiaires et obtient la longueur en créant une urange de la même longueur que la liste et en prenant le dernier élément.

Haskell, 43 octets

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

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

Haskell n'a pas de listes mixtes ( Integermélangées avec List of Integer), donc je ne peux pas exploiter certaines fonctions de détection de liste et je dois analyser la chaîne.

Je commence par la droite avec 0et ajoutez 1 pour chaque ], soustrayez 1 pour chaque [et conservez la valeur autrement. scanrconserve tous les résultats intermédiaires, donc maximumpeut faire son travail.

JavaScript (ES6), 35 octets

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

Explication

Fonction récursive qui renvoie la profondeur maximale d'un tableau, ou 0si passé un nombre.

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 octets

'}{'!=dYsX>

Les accolades sont utilisées dans MATL pour ce type de tableaux. Quoi qu'il en soit, l'entrée est prise et traitée sous la forme d'une chaîne, de sorte que les crochets peuvent également être utilisés, modifiant les deux caractères du code.

Essayez-le en ligne!

          % 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

Octave, 29 octets

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

Mappe [à 1 et ]à -1, puis prend le maximum de la somme cumulée.

L'entrée est une chaîne de la forme

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

Exemple de run sur ideone .

Julia, 55 26 octets

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

Il s'agit d'une fonction récursive qui accepte un tableau unidimensionnel avec un contenu de type Anyet renvoie un entier. Lorsque vous passez un tableau à la fonction, préfixez tous les crochets avec Any, c.-à-d f(Any[1,Any[2,3]]).

L'approche est assez simple. Pour une entrée a , nous multiplions a par 0 et vérifions si le résultat est le scalaire 0. Sinon, nous savons que a est un tableau, nous appliquons donc la fonction à chaque élément de a , prenons le maximum et ajoutons 1.

Sauvegardé 29 octets grâce à Dennis!

Rubis, 53 octets

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

Entrée depuis STDIN, sortie vers 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

Gelée, 10 7 octets

¬;/SпL

Essayez-le en ligne! ou vérifier tous les cas de test .

Comment ça marche

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

Mise à jour

En écrivant cette réponse, j'ai remarqué que Jelly se comporte plutôt bizarrement pour les listes irrégulières, car j'ai calculé la profondeur d'une liste comme le minimum incrémenté des profondeurs de ses éléments.

Cela a été résolu dans la dernière version, donc le code suivant ( 6 octets ) fonctionnerait maintenant.

¬SSпL

Cela additionne les lignes du tableau au lieu de les concaténer.

Mathematica, 18 octets

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

Mathematica, 27 20 octets

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

Fonction récursive simple.

PHP, 61 octets

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

fonction récursive qui s'utilise comme fonction de mappage pour remplacer chaque élément par sa profondeur.

PHP, 84 72 64 63 60 octets

Remarque: nécessite PHP 7 pour l'opérateur de comparaison combiné. Utilise également le codage IBM-850

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

Courez comme ça:

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

• Enregistré 12 octets en comptant simplement les accolades de la représentation de chaîne à la place
• 8 octets enregistrés en simplifiant les comparaisons de chaînes et en utilisant le nombre ordinal du caractère en cas de [et]
• Enregistré un octet en ne convertissant pas $ien un int. Les décalages de chaîne sont castés implicitement en entier
• Enregistré 3 octets en utilisant l'opérateur de comparaison combiné au lieu du nombre ordinal

C, 98 69 octets

29 octets de réduction merci @DigitalTrauma !!

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

Prend une chaîne en entrée et renvoie le résultat sous forme d'entier.

Exemple en direct dans: http://ideone.com/IC23Bc

Python 3, 42 39 octets

-3 octets grâce à Sp3000

Il s'agit essentiellement d'un portage de la solution Python 2 de xnor :

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

Malheureusement, [] > {}renvoie une unorderable typeserreur, de sorte que cette astuce particulière de xnor ne peut pas être utilisée. À sa place, la -0123456789valeur ASCII Aest inférieure à [], qui est inférieure à , d'où la comparaison de chaînes fonctionne.

CJam (15 octets)

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

Démo en ligne

Dissection

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

Pour la même longueur mais plutôt plus en laid hack,

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

Sed, 40 caractères

(Code de 39 caractères + option de ligne de commande de 1 caractère.)

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

Entrée: chaîne, sortie: nombre unaire.

Échantillon échantillon:

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 caractères

(Code de 32 caractères + option de ligne de commande de 1 caractère.)

Si des espaces de fin sont autorisés dans la sortie.

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

Entrée: chaîne, sortie: nombre unaire.

Échantillon échantillon:

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 octets

Edit : Merci @Martin Ender ♦ de m'avoir sauvé 1 octet de la merveilleuse astuce -1!

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

Essayez-le en ligne pour vérifier les cas de test!

Les images ci-dessous ne sont pas modifiées mais le flux est fondamentalement le même. Notez également que cela retournera -1si l'entrée n'est pas un tableau (c'est-à-dire sans []).

J'ai beaucoup de non-op à l'intérieur de l'Hexagone ... Je suppose qu'il peut certainement être joué plus.

Explication

En bref, il ajoute -1quand rencontre a [et ajoute 1quand rencontre a ]. Enfin, il imprime le maximum qu'il a.

Exécutons le cas de test 5 pour voir son comportement lorsqu'il s'exécute le long de la chaîne [1, [[3]], [5, 6], [[[[8]]]], 1]:

Il commence au début et prend son entrée dans le coin W:

Puisqu'il y a toujours une entrée (pas le caractère nul \0ou EOL), il retourne en haut et démarre le chemin cramoisi.

Voici ce qui se passe quand de là à mignon ><:

,lit [dans Buffer {et Zdéfinit la constante Z à 90. 'se déplace vers Diff et -calcule la différence. Pour [et ]la différence sera 1et 3respectivement. Pour les nombres, les espaces et les virgules, ce sera négatif.

Ensuite, nous courons (deux fois (une fois à la fin du chemin cramoisi, une au début après avoir enveloppé le chemin vert) pour obtenir -1et 1resp pour [et ]. Ici, nous changeons le nom de Diffen Value. Ajoutez cette valeur à la profondeur. (J'avais l'habitude Z&de m'assurer qu'il copie le bon voisin). Ensuite, nous calculons lastMin - Depthet obtenons un nombre sur le bord de la mémoire minLR.

Ensuite, nous appliquons &(à la fin du chemin vert) à minLR: Si le nombre est <= 0, il copie la valeur de gauche (c'est-à-dire lastMin - Depth <= 0 => lastMin <= Depth), sinon il prend la bonne valeur.

Nous nous enroulons sur le chemin horizontal bleu et nous voyons à Z&nouveau qui copie le minLR. Ensuite, nous avons "&fait une copie du min calculé. Les crochets sont supposés être équilibrés, donc le min doit être <= 0. Après l'emballage, le chemin bleu va à gauche et frappe (, ce qui rend la copie 1inférieure au vrai min. En réutilisant le -, nous avons créé une copie supplémentaire en tant que voisin de Buffer:

Remarque: copyest renommé en1-off

Lorsque le chemin bleu frappe \et obtient une belle "et le <rattrape dans la boucle principale.

Lorsque la boucle frappe 1, ,ou ou d'autres nombres en entrée:

Le Diff deviendra négatif et il sera reflété dans la boucle principale pour la prochaine entrée.

Lorsque tout est passé par la boucle principale, nous atteignons EOL qui fait Buffer -1et il va finalement au bord inférieur:

'déplace le MP vers 1-off copyet l' )incrémente, et avec la ~négation, il obtient la valeur de profondeur maximale correcte qui est imprimée avec!

Et l'histoire se termine par un @.

Je suppose que je dois avoir trop compliqué les choses un peu. Si je n'avais eu qu'à "reculer" et "imprimer" sans incrémentation ni négation, j'aurais bien économisé 2 octets sans utiliser l'hexagone complet.

Un grand merci à Timwi pour l' ésotérique IDE et Hexagony Colorer !

brainfuck, 48 octets

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

Formaté:

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

Prend l'entrée formatée comme (1, ((3)), (5, 6), ((((8)))), 1)et génère une valeur d'octet .

Essayez-le en ligne.

Cela stocke la profondeur par emplacement de mémoire, en déplaçant le pointeur vers la droite (et la gauche pour )et en ignorant les autres caractères. Les cellules visitées sont marquées d'un 1drapeau, donc à la fin de la boucle principale, il y aura des depth + 1drapeaux à droite de la cellule actuelle. Ceux-ci sont ensuite ajoutés pour imprimer le résultat final.

Une solution précédente de 69 octets utilisant une approche différente:

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

Dans cette version, la profondeur et la profondeur maximale sont stockées explicitement dans les cellules.

Pyth, 15 13 octets

-2 octets par @Maltysen

eSm-F/Ld`Y._z

Compte la différence entre les comptes cumulés de [et ], et prend le maximum. Yest le tableau vide, et sa représentation sous forme de chaîne ( `) est commodément [].

Essayez-le ici .

CJam, 19 22 23 octets

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

Idée similaire à ma réponse MATL.

Merci à Peter Taylor d'avoir supprimé 3 octets

Essayez-le ici

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 octets

32, plus deux pour -p

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

Stolen du numérique Trauma de réponse Retina ... qui est 26% plus court que cela.:-)

Ou, également:

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

Ruby, 51 caractères

(Commencé en tant que suggestion d'amélioration pour la réponse Ruby de Doorknob mais terminé différemment. Je l'ai donc publiée comme réponse distincte. Les votes positifs pour l'idée de comptage de profondeur ( , descendant de ) devraient aller à la réponse d'origine.)?\\<=>$&'] ['.index(c)

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

Entrée: chaîne, sortie: nombre.

Échantillon échantillon:

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 octets

La fermeture:

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

A besoin d'un argument, par exemple:

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

Explication:

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

J'ai révisé mon algorithme suite à l'inspiration de la réponse CJam de Luis Mendo et économisé 5 octets!

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

Essayez-le ici!

Explication

Essentiellement, ce code fait garder un total cumulé avec +1 pour chacun [et -1 pour chacun ], en gardant une trace de la valeur maximale atteinte, en sortant ce maximum à la fin. Le bouclage est géré par la nature toroïdale de la boîte à codes 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 caractères

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

Paramètre: tableau, retour: nombre.

Échantillon échantillon:

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 octets

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

Non-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 crée une ligne par caractère dans la chaîne d'entrée.

Le SUBSTR isole le caractère correspondant au numéro de ligne.

Le DECODE traduit chaque «[» en 1, chaque «]» en -1 et chaque autre caractère en 0.

Le SUM analytique additionne chacun 1, -1 et 0 des lignes précédentes, y compris la ligne actuelle;

La somme MAX est la profondeur.

Java 8, 95

Il s'agit d'une expression lambda pour a ToIntFunction<String>. L'entrée est considérée comme un Stringdans le format d'exemples de l'OP.

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

assez simple. Fractionnez la chaîne en utilisant [comme délimiteur. Pour chacun d'eux, incrémentez le compteur eet comparez-le avec le compteur d, en gardant le plus grand d'entre eux d. Ensuite, divisez la chaîne de l'itération actuelle en utilisant ]cette fois comme délimiteur et soustrayez le nombre de divisions supplémentaires e.