Nesse desafio, você deve analisar uma lista de listas em um formato de lista mais simples.

Esse desafio é baseado no meu analisador sadflak. No meu analisador sadflak, todos os () foram removidos, substituídos pela soma dos () s no início da lista, para acelerar a execução do programa.

Para analisar uma Sad-List, você precisa fazer isso (coisa de implementação em python, usa uma tupla de tuplas):

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

Esta é uma função recursiva. Para uma lista, inicie uma nova lista, começando com o número de () da entrada da lista e, em seguida, o restante desta lista são versões da lista triste de todas as listas que não eram () da entrada da lista, em ordem. retorne a lista.

Entrada:

você pode receber entradas em alguns formatos diferentes:

• você pode tomá-lo como uma lista
• você pode tomá-lo como uma tupla
• você pode tomá-lo como uma corda

se você a usar como uma corda, use algum conjunto de colchetes, como aparece no cérebro. você não pode usar os caracteres 1 e 2

apenas seja razoável

A entrada sempre estará dentro de uma lista, mas seu programa pode assumir uma camada de lista implícita fora da entrada, ou seja, () () () = (() () ())) ou pode optar por não. Exemplos serão com lista externa explícita

resultado:

pode ser lista ou tupla ou string, ou qualquer outra coisa. você pode usar qualquer formato de saída razoável, como é o meta consenso.

Exemplo:

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

note que a entrada não é estrita. essas entradas podem ser:

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

ou algum outro formato razoável

caso de teste explicado:

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

para "entristecer" isso, primeiro contamos o número de ()

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

3. depois removemos e adicionamos um 3 no início

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

existe uma lista nesta lista. nós entristecemos isso

((())())

quantos ()?

     ()
((())  )

1. removemos e adicionamos um 1 no início

(1,(()))

isso tem uma lista nele

(())

contagem

 ()
(  )

remover e adicionar contagem

(1)

então colocamos isso de volta em sua lista

(1,(1))

então colocamos isso de volta em sua lista

(3,(1,(1)))

feito

Isso é código-golfe , então quanto menor, melhor

Pitão , 13 bytes

L+]/bYyM-b]Yy

Conjunto de teste .

Como funciona

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 bytes

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

tome entrada como lista de listas.

Experimente online!

Braquilog , 21 bytes

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

Experimente online!

Mathematica, 42 bytes

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

Evita recursão explícita usando //@( MapAll) que mapeia uma função sobre cada nó em uma árvore. Isso também significa que as funções são executadas das folhas para cima. No entanto, ele também será aplicado ao {}qual será transformado {0}no processo. É por isso que contamos e remover {0}vez {}.

Retina , 42 bytes

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

Experimente online!

Clojure, 59 bytes

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

Não é muito diferente da resposta do CommonLisp . É counte removeparece aceitar uma construção um pouco melhor, aqui eu tive que usar conjuntos.

Na verdade , 12 bytes

;[]@c@;░Q£Mo

Experimente online!

Recebe entrada como uma lista de colchetes separados por vírgula com colchetes externos explícitos.

Explicação:

;[]@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 bytes

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

Experimente online!

Gelatina , 10 bytes

Tị߀;@ċ“”$

Experimente online!

Recebe entrada como lista de listas de listas ...

Obviamente, ele usa o algoritmo usado pelas outras respostas. ;)

Haskell , 102 bytes

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

Experimente online!

Como Haskell é estritamente digitado, não há listas aninhadas arbitrariamente. Como remédio, data L=I Int|T[L]deriving Showdeclara listas aninhadas em forma de árvore com Ints ou listas vazias como folhas.

Entrada é como no segundo exemplo formato, com um construtor adicional Tantes de cada chave de abertura: T[T[T[]],T[],T[T[]]]. O mesmo vale para a saída, com cada número sendo precedido por um construtor I. Função fexecuta o entristecimento .

Saídas para os casos de teste:

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 bytes

Golfe:

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

Demo

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>