En este desafío, debe analizar una lista de listas en un formato de lista más simple.

Este desafío se basa en mi analizador sadflak. En mi analizador sadflak, tiene todo el () eliminado, reemplazado por la suma de los () s al comienzo de la lista, para que el programa se ejecute más rápido.

Para analizar en una Lista triste, debe hacer esto (lo de la implementación de Python, usa una 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 es una función recursiva. Para una lista, comience una nueva lista, comenzando con el número de () de la entrada de la lista, luego el resto de esta lista son versiones de lista triste de cada lista que no era un () de la entrada de la lista, en orden. devolver la lista

Entrada:

Puede tomar la entrada en algunos formatos diferentes:

• puedes tomarlo como una lista
• puedes tomarlo como una tupla
• puedes tomarlo como una cuerda

Si lo toma como una cuerda, debe usar un conjunto de corchetes, como aparece en el cerebro-flak. no puedes usar los caracteres 1 y 2

solo se razonable

La entrada siempre estará dentro de una lista, pero su programa puede asumir una capa de lista implícita fuera de la entrada, es decir () () () = (() () ()), o puede elegir no hacerlo. Los ejemplos serán con lista externa explícita

salida:

puede ser list o tuple o string, o lo que sea. puede usar cualquier formato de salida razonable, como es el meta consenso.

Ejemplo:

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

Tenga en cuenta que la entrada no es estricta. Estas entradas podrían ser:

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

o algún otro formato razonable

caso de prueba explicado:

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

para "entristecer" esto, primero contamos el número de ()

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

3. luego los eliminamos y agregamos un 3 al comienzo

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

Hay una lista en esta lista. lamentamos esto

((())())

cuántos ()?

     ()
((())  )

1. eliminamos y agregamos un 1 al comienzo

(1,(()))

esto tiene una lista

(())

contar

 ()
(  )

eliminar y agregar recuento

(1)

luego volvemos a poner esto en su lista

(1,(1))

luego volvemos a poner esto en su lista

(3,(1,(1)))

hecho

Este es el código de golf , así que más corto es mejor

Pyth , 13 bytes

L+]/bYyM-b]Yy

Banco de pruebas .

Cómo 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))))

tomar entrada como lista de listas.

Pruébalo en línea!

Brachylog , 21 bytes

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

Pruébalo en línea!

Mathematica, 42 bytes

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

Evita la recursividad explícita al usar //@( MapAll), que asigna una función sobre cada nodo en un árbol. Esto también significa que las funciones se ejecutan desde las hojas hacia arriba. Sin embargo, también se aplicará a los {}que se convierten {0}en el proceso. Es por eso que contamos y eliminamos en su {0}lugar {}.

Retina , 42 bytes

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

Pruébalo en línea!

Clojure, 59 bytes

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

No es muy diferente de la respuesta CommonLisp . Es county removeparece aceptar una construcción un poco más agradable, aquí tuve que usar conjuntos.

En realidad , 12 bytes

;[]@c@;░Q£Mo

Pruébalo en línea!

Toma datos como una lista de corchetes separados por comas con paréntesis externos explícitos.

Explicación:

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

Pruébalo en línea!

Jalea , 10 bytes

Tị߀;@ċ“”$

Pruébalo en línea!

Toma entrada como lista de listas de listas ...

Por supuesto, usa el algoritmo que usan las otras respuestas. ;)

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

Pruébalo en línea!

Debido a que Haskell está estrictamente escrito, no hay listas anidadas arbitrariamente. Como remedio, se data L=I Int|T[L]deriving Showdeclaran listas anidadas en forma de árbol con Ints o listas vacías como hojas.

De entrada es igual que en el segundo formato de ejemplo, con un constructor adicional Tantes de cada llave de apertura: T[T[T[]],T[],T[T[]]]. Lo mismo ocurre con la salida, con cada número precedido por un constructor I. La función frealiza el entristecimiento .

Salidas para los casos de prueba:

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

Golfizado:

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

Sin golf:

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

Manifestación

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>