Простое испытание для вашего вечера понедельника (ну, или утро вторника в другой половине мира ...)

В качестве входных данных вы получаете вложенный, потенциально рваный массив натуральных чисел:

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

Ваша задача - определить его глубину, которая является наибольшей глубиной вложенности любого целого числа в списке. В этом случае глубина 11IS 6, которая является самой крупной.

Вы можете предположить, что ни один из массивов не будет пустым.

Вы можете написать программу или функцию, принимая ввод через STDIN (или ближайшую альтернативу), аргумент командной строки или аргумент функции и выводя результат через STDOUT (или ближайшую альтернативу), возвращаемое значение функции или параметр функции (out).

Ввод может быть сделан в любом удобном формате списка или строки, который поддерживает непрямоугольные массивы (с вложенными массивами различной глубины), если фактическая информация не была предварительно обработана.

Вы не должны использовать какие-либо встроенные модули, связанные с формой массивов (включая встроенные модули, которые решают эту задачу и получают размеры вложенного массива). Единственное исключение - получение длины массива.

Применяются стандартные правила игры в гольф .

Тестовые случаи

[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

К, 4 байта

#,/\

В K ,/будут объединены все элементы списка. Общая идиома ,//повторяется до фиксированной точки, полностью сглаживая произвольно вложенный список. ,/\выполняет итерацию до фиксированной точки аналогичным образом, но собирает список промежуточных результатов. Подсчитав, сколько промежуточных результатов мы видим до достижения фиксированной точки ( #), мы получаем желаемый ответ: максимальная глубина вложения.

Msgstr "Количество соединений по сканированию с фиксированной точкой".

В бою:

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

Сетчатка , 10

• Сохранено 1 байт благодаря @ ӍѲꝆΛҐӍΛПҒЦꝆ
• Сохранено 14 дополнительных байтов благодаря @ MartinBüttner

+ `\ Ш |} {

{

Здесь формат ввода немного надуманный - _символы используются для разделителей списков, поэтому вход будет выглядеть так{1_{{2_3_{{4}_5}_6_{7_8}}_9_{10_{{{11}}}}_12_13}_14}

• Этап 1 - многократно удаляются }{и все остальные \wперсонажи. Это приводит к тому, что а) все списки на всех уровнях состоят только из одного элемента и б) удаляются все неструктурные символы списка.
• Этап 2 - подсчет оставшихся {. Это дает самый глубокий уровень вложенности.

Попробуйте онлайн.

Если это слишком много, то предыдущий ответ был:

Сетчатка , 13

Предполагается, что списки содержатся в фигурных скобках {}.

+ `[^} {] |} {

{

Попробуйте онлайн .

Python 2, 33 байта

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

Рекурсивно определяет глубину, говоря, что глубина числа равна 0, а глубина списка на единицу больше максимальной глубины его элементов. Число против списка проверяется путем сравнения с пустым словарем {}, который выпадает выше цифр, но ниже списков в произвольном порядке Python 2 встроенных типов.

Pyth - 11 10 7 байт

1 байт сохранен благодаря @Dennis

4 байта сохранены благодаря @Thomas Kwa

eU.usNQ

Попробуйте это онлайн здесь .

Продолжает суммировать массив до тех пор, пока он не перестанет изменяться, что означает его просто число, делает это кумулятивно, чтобы сохранить все промежуточные результаты и получает длину, создавая urange такой же длины, что и список, и беря последний элемент.

Haskell, 43 байта

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

Пример использования: maximum.scanr(#)0 $ "[1, [[3]], [5, 6], [[[[8]]]], 1]"-> 5.

У Haskell нет смешанных списков ( Integerсмешанных с List of Integer), поэтому я не могу использовать некоторые функции обнаружения списков, и мне нужно проанализировать строку.

Я начинаю справа с 0и добавляю 1 для каждого ], вычитаю 1 для каждого [и сохраняю значение в противном случае. scanrсохраняет все промежуточные результаты, так что maximumможете делать это.

JavaScript (ES6), 35 байт

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

объяснение

Рекурсивная функция, которая возвращает максимальную глубину массива или 0если передано число.

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 байт

'}{'!=dYsX>

Фигурные скобки используются в MATL для этого типа массивов. В любом случае, входные данные берутся и обрабатываются как строка, поэтому одинаково можно использовать квадратные скобки, изменяя два символа в коде.

Попробуйте онлайн!

          % 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

Октава, 29 байт

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

Сопоставляет [с 1 и ]с -1, затем берет максимум совокупной суммы.

Ввод - это строка вида

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

Пробный прогон на идеоне .

Юлия, 55 26 байтов

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

Это рекурсивная функция, которая принимает одномерный массив с содержимым типа Anyи возвращает целое число. При передаче массива функции, префикс всех скобок с Any, то есть f(Any[1,Any[2,3]]).

Подход довольно прост. Для входа a мы умножаем a на 0 и проверяем, является ли результат скаляром 0. Если нет, мы знаем, что a является массивом, поэтому мы применяем функцию к каждому элементу a , берем максимум и добавляем 1.

Благодаря Денису сэкономлено 29 байт!

Рубин, 53 байта

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

Ввод из STDIN, вывод в 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

Желе, 10 7 байт

¬;/SпL

Попробуйте онлайн! или проверьте все контрольные примеры .

Как это работает

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

Обновить

При написании этого ответа я заметил, что Jelly ведет себя довольно странно для рваных списков, потому что я вычислял глубину списка как увеличенный минимум глубин его элементов.

Это было исправлено в последней версии, поэтому следующий код ( 6 байт ) будет работать сейчас.

¬SSпL

Это суммирует строки массива, а не объединяет их.

Mathematica, 18 байт

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

Mathematica, 27 20 байтов

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

Простая рекурсивная функция.

PHP, 61 байт

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

рекурсивная функция, которая использует себя как функцию отображения для замены каждого элемента его глубиной.

PHP, 84 72 64 63 60 байт

Примечание: требуется PHP 7 для оператора комбинированного сравнения. Также использует кодировку IBM-850

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

Запустите так:

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

• Сохранено 12 байт, просто посчитав вместо этого фигурные скобки строкового представления
• Сохранено 8 байтов за счет упрощения сравнения строк и использования порядкового номера символа в случае [и]
• Сохраненный байт, не приведя $iк int. Смещения строк приводятся к int неявным образом
• Сохранено 3 байта с использованием объединенного оператора сравнения вместо порядкового номера

C 98 69 байт

29 байтов, спасибо @DigitalTrauma !!

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

Принимает строку в качестве входных данных и возвращает результат как целое число.

Живой пример в: http://ideone.com/IC23Bc

Python 3, 42 39 байт

-3 байта благодаря Sp3000

По сути это порт решения xnor Python 2 :

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

К сожалению, [] > {}возвращает unorderable typesошибку, так что конкретный хитрый прием xnor's не может быть использован. На его месте, -0123456789ниже в ASCII значение, чем A, что ниже [], следовательно, сравнение строк работает.

CJam (15 байт)

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

Онлайн демо

рассечение

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

Для той же длины, но скорее на уродливой территории,

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

Сед, 40 знаков

(39 символов кода + 1 символ опции командной строки.)

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

Вход: строка, выход: унарный номер.

Образец прогона:

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

Сед, 33 персонажа

(32 символа кода + 1 символ опции командной строки.)

Если в выводе допускаются конечные пробелы.

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

Вход: строка, выход: унарный номер.

Образец прогона:

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      

Гексагония , 61 байт

Редактировать : Спасибо @Martin Ender ♦ за спасение меня 1 байт от чудесного трюка -1!

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

Попробуйте онлайн, чтобы проверить контрольные примеры!

Изображения ниже не изменены, но поток в основном такой же. Также обратите внимание, что это будет возвращаться, -1если входные данные не являются массивом (т.е. без []).

У меня в "Шестиграннике" много бездействующих ... Я думаю, что это определенно может быть больше в гольфе.

объяснение

Вкратце, он добавляет, -1когда встречает a, [и добавляет, 1когда встречает a ]. Наконец он печатает максимум, что получил.

Давайте пробежимся по тестовому примеру 5, чтобы увидеть его поведение при выполнении по строке [1, [[3]], [5, 6], [[[[8]]]], 1]:

Он начинается в начале и принимает свой вклад в углу W:

Поскольку все еще есть ввод (не нулевой символ \0или EOL), он переносится наверх и запускает малиновый путь.

Вот что происходит, когда оттуда до симпатичного ><:

,считывает [в Buffer {и Zустанавливает константу Z равной 90. 'переходит в Diff и -вычисляет разницу. Ибо [и ]разница будет 1и 3соответственно. Для чисел, пробелов и запятых это будет отрицательным.

Затем мы запускаем (дважды (один раз в конце алого пути, один в начале после переноса на зеленый путь), чтобы получить -1и 1соответственно для [и ]. Здесь мы меняем наименование Diffна Value. Добавьте это значение в глубину. (Я использовал, Z&чтобы убедиться, что он копирует правильного соседа). Затем мы вычисляем lastMin - Depthи получаем число на границе памяти minLR.

Затем мы применяем &(в конце зеленого пути) к minLR: Если число <= 0, оно копирует левое значение (т.е. lastMin - Depth <= 0 => lastMin <= Depth), в противном случае оно принимает правильное значение.

Мы свернем на горизонтальную синюю дорожку и Z&снова увидим, кто копирует minLR. Тогда мы "&и сделали копию рассчитанного мин. Скобки предполагаются сбалансированными, поэтому min должно быть <= 0. После обертывания синий путь идет влево и нажимает (, делая копию 1меньше реальной мин. Повторно используя -, мы создали еще одну однократную копию в качестве соседа Buffer:

Примечание: copyпереименовано в1-off

Когда синяя дорожка попадает \и получает хороший "и <ловит его обратно в основной цикл.

Когда хиты цикла 1, ,или или другие номера в качестве входных данных:

Разница станет отрицательной, и она будет отражена обратно в основной цикл для следующего ввода.

Когда все проходит через основной цикл, мы достигаем EOL, который создает Buffer, -1и он, наконец, переходит к нижнему краю:

'перемещает MP к 1-off copyи )увеличивает его, и с ~отрицанием он получил правильное значение максимальной глубины, которое печатается с!

И история заканчивается @.

Наверное, я немного усложнил ситуацию. Если бы мне пришлось только «двигаться назад» и «печатать» без приращения и отрицания, я бы хорошо сохранил 2 байта без использования полного шестиугольника.

Большое спасибо Тимви за Эзотерическую IDE и Hexagony Colorer !

брейкфук, 48 байт

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

отформатирован:

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

Принимает форматированный ввод (1, ((3)), (5, 6), ((((8)))), 1)и выводит байтовое значение .

Попробуйте онлайн.

Это сохраняет глубину по месту в памяти, перемещая указатель вправо (и влево )и игнорируя другие символы. Посещенные ячейки помечены 1флажком, поэтому в конце основного цикла depth + 1справа от текущей ячейки будут флажки. Затем они добавляются для печати окончательного результата.

Предыдущее 69-байтовое решение с использованием другого подхода:

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

В этой версии глубина и максимальная глубина хранятся явно в ячейках.

Pyth, 15 13 байт

-2 байта @Maltysen

eSm-F/Ld`Y._z

Подсчитывает разницу между совокупным количеством [и ]и принимает максимум. Yэто пустой массив, и его строковое представление ( `) удобно [].

Попробуй это здесь .

CJam, 19 22 23 байта

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

Идея, аналогичная моему ответу в MATL.

Спасибо Питеру Тейлору за удаление 3 байтов

Попробуй здесь

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 байта

32 плюс два для -p

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

Похищенные из Digital Trauma «s Retina ответ ... что на 26% меньше , чем это.:-)

Или, в равной степени:

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

Рубин, 51 персонаж

(Начинала как рационализаторское предложение для дверной ручки «s Рубите ответ , но в итоге по- разному. Так что я отправил его в качестве отдельного ответа. Upvotes за идею глубины счета ( ?\\<=>$&, спускающееся с '] ['.index(c)) следует перейти к первоначальному ответу.)

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

Вход: строка, выход: число.

Образец прогона:

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 байта

Закрытие:

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

Нужен аргумент, например:

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

Объяснение:

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

Минколанг 0,15 , 31 29 24 байта

Пересмотрел мой алгоритм по вдохновению от ответа CJam Луиса Мендо и сэкономил 5 байт!

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

Попробуй это здесь!

объяснение

По сути, этот код сохраняет промежуточную сумму с +1 для каждого [и -1 для каждого ], отслеживая достигнутое максимальное значение, выводя этот максимум в конце. Циклы обрабатываются тороидальной природой кодового поля Минколанга.

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

Рубин, 41 персонаж

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

Параметр: массив, возвращаемый: номер.

Образец прогона:

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 байта

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 создает одну строку на символ во входной строке.

SUBSTR выделяет символ, соответствующий номеру строки.

DECODE переводит каждый '[' в 1, каждый ']' в -1, а каждый другой символ в 0.

Аналитическая SUM суммирует каждые 1, -1 и 0 из предыдущих строк, включая текущую строку;

МАКС. Суммы - это глубина.

Ява 8, 95

Это лямбда-выражение для ToIntFunction<String>. Ввод принимается какString в формате примеров ОП.

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

довольно простой. Разбейте строку, используя [в качестве разделителя. Для каждого из них увеличьте счетчик eи сравните его со счетчиком d, сохраняя большее из них d. Затем разделите строку текущей итерации, используя ]на этот раз в качестве разделителя, и вычтите количество дополнительных разбиений из e.