В этой задаче вы должны разобрать список списков в более простой формат списка.

Этот вызов основан на моем парсере sadflak. В моем анализаторе sadflak все () удалено, заменено суммой () в начале списка, чтобы программа работала быстрее.

Чтобы разобраться в Sad-List, вы должны сделать это (вещь реализации Python, использует кортеж кортежей):

def sadlistfunc(list):
    new-sadlist = [0]
    for i in list:
        if i == ():
            new-sadlist[0]+=1
        else:
            new-sadlist.append(sadlistfunc(i))

Это рекурсивная функция. Для списка начните новый список, начиная с номера () из входного списка, затем остальная часть этого списка - это версии всех списков, которые не были () из входного списка, по порядку. вернуть список.

Входные данные:

Вы можете принимать входные данные в нескольких разных форматах:

• Вы можете принять это как список
• Вы можете принять это как кортеж
• вы можете принять это как строку

если вы воспринимаете это как строку, вы должны использовать несколько скобок, как показано в мозговом флаке. Вы не можете использовать символы 1 и 2

просто будь разумным

Ввод всегда будет находиться внутри одного списка, но ваша программа может предполагать наличие неявного слоя списка за пределами ввода, т. Е. () () () = (() () ()), Или она может отказаться. Примеры будут с явным внешним списком

выход:

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

Пример:

(()()()) = [3]
(((()))) = [0,[0,[1]]]
((())()(())) = [1, [1], [1]]
() = invalid input, if the outside bracket is explicit.
((((())())())(())()) = [1, [1, [1, [1]]], [1]]

обратите внимание, что ввод не является строгим. эти входные данные могут быть:

[[],[],[]]
[[[[]]]]
[[[]],[],[[]]]
[]
[[[[[]],[]],[]],[[]],[]]

или какой-то другой разумный формат

объяснил контрольный пример:

(()()((())())())

чтобы «осквернить» это, сначала посчитаем количество ()

 ()()        ()
(    ((())())  )

3. затем мы удалим их и добавим 3 в начале

(3,((())()))

в этом списке есть один список мы опечаливаем это

((())())

Как много ()?

     ()
((())  )

1. убираем и добавляем 1 в начале

(1,(()))

это один список

(())

подсчитывать

 ()
(  )

удалить и добавить счет

(1)

затем мы помещаем это обратно в свой список

(1,(1))

затем мы помещаем это обратно в свой список

(3,(1,(1)))

сделано

Это код-гольф , поэтому чем короче, тем лучше

Pyth , 13 байт

L+]/bYyM-b]Yy

Тестовый пакет .

Как это устроено

L+]/bYyM-b]Yy
L               define a function y with argument b:
   /bY              list 1: count how many [] can be found in b
  ]                         wrap into singleton
        -b]Y        list 2: filter out [] from b
      yM                    apply y (this function) to each
 +                  concatenate the two lists above
            y   apply y to the input

CommonLisp, 49 байт

(defun s(l)(cons(count()l)(mapcar's(remove()l))))

принять вход как список списков.

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

Брахилог , 21 байт

;[[]]x{↰₀}ᵐA&{∋∅}ᶜg,A

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

Mathematica, 42 байта

{#~Count~{0},##&@@#~DeleteCases~{0}}&//@#&

Предотвращает явную рекурсию с помощью //@( MapAll), которая отображает функцию на каждый узел дерева. Это также означает, что функции выполняются от листьев вверх. Тем не менее, он также будет применен к тому, в {}который превращаются в {0}процессе. Вот почему мы считаем и удаляем {0}вместо этого {}.

Сетчатка , 42 байта

+`(({()|}(?<-3>))*)(?!\3){}
1$1
{(1*)
{$.1

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

Clojure, 59 байт

(fn f[i](conj(map f(remove #{[]}i))(count(filter #{[]}i))))

Не сильно отличается от ответа CommonLisp . Его countи, removeкажется, принять немного более приятную конструкцию, здесь я должен был использовать наборы.

На самом деле , 12 байтов

;[]@c@;░Q£Mo

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

Принимает ввод как разделенный запятыми список квадратных скобок с явными внешними скобками.

Объяснение:

;[]@c@;░Q£Mo
;[]@c         count the number of empty lists
     @;░      filter out empty lists
        Q£Mo  recurse with filtered list and append result

Python 2 , 69 46 45 байт

f=lambda l:[l.count([])]+map(f,filter(len,l))

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

Желе , 10 байт

Tị߀;@ċ“”$

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

Принимает ввод как список списков списков ...

Конечно, он использует алгоритм, который используют другие ответы. ;)

Haskell , 102 байта

data L=I Int|T[L]deriving Show
(I n:r)#m=r#(n+m)
(x:r)#m=x:r#m
_#m=[I m]
f(T[])=I 1
f(T t)=T$map f t#0

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

Поскольку Haskell строго типизирован, нет произвольно вложенных списков. В качестве средства защиты data L=I Int|T[L]deriving Showобъявляются древовидные вложенные списки с целыми или пустыми списками в качестве листьев.

Входные данные , как во втором примере формате, с дополнительным конструктором Tперед каждой открывающей скобкой: T[T[T[]],T[],T[T[]]]. То же самое относится и к выводу, где каждому числу предшествует конструктор I. Функция fвыполняет печаль .

Выходы для тестовых случаев:

T [I 3]
T [T [T [I 1],I 0],I 0]
T [T [I 1],T [I 1],I 1]
T [T [T [T [I 1],I 1],I 1],T [I 1],I 1]

Javascript (ES6), 77 байт

Golfed:

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

Ungolfed:

const traverse = arr => !arr.length || arr
    .map(traverse)
    .reduce(
        (accum, val) => (val.length ? accum.push(val) : accum[0]++, accum),
        [0]
    );

демонстрация

let m=a=>!a.length||a.map(m).reduce((b,c)=>(c.length?b.push(c):b[0]++,b),[0])

o.innerHTML = [
    JSON.stringify(m([[],[],[]])),
    JSON.stringify(m([[[[]]]])),
    JSON.stringify(m([[[]],[],[[]]])),
    JSON.stringify(m([])),
    JSON.stringify(m([[[[[]],[]],[]],[[]],[]]))
].join('\n')

<pre id=o></pre>