In questa sfida, è necessario analizzare un elenco di elenchi, in un formato elenco più semplice.

Questa sfida si basa sul mio parser sadflak. Nel mio parser sadflak, è stato rimosso tutto (), sostituito con la somma dei () s all'inizio dell'elenco, per rendere il programma più veloce.

Per analizzare una lista triste, devi fare questo (cosa di implementazione di Python, usa una tupla di tuple):

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

Questa è una funzione ricorsiva. Per un elenco, avvia un nuovo elenco, iniziando con il numero di () dall'input dell'elenco, quindi il resto di questo elenco contiene le versioni dell'elenco triste di ogni elenco che non era un () dall'input dell'elenco, in ordine. ritorna alla lista.

Ingresso:

puoi inserire input in diversi formati:

• puoi prenderlo come un elenco
• potresti prenderlo come una tupla
• puoi prenderlo come una stringa

se lo prendi come una stringa, dovresti usare una serie di parentesi, come appare nel cervello-flak. non puoi usare i caratteri 1 e 2

sii ragionevole

L'input sarà sempre all'interno di un elenco, ma il programma potrebbe assumere un livello elenco implicito al di fuori dell'input, ovvero () () () = (() () ()), oppure potrebbe scegliere di non farlo. Gli esempi saranno con un elenco esterno esplicito

produzione:

può essere elenco o tupla o stringa o altro. è possibile utilizzare qualsiasi formato di output ragionevole, come è il meta consenso.

Esempio:

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

si noti che l'input non è rigoroso. questi input potrebbero essere:

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

o qualche altro formato ragionevole

caso di prova spiegato:

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

per "sadificare" questo, prima contiamo il numero di ()

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

3. quindi li rimuoviamo e aggiungiamo un 3 all'inizio

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

c'è un elenco in questo elenco. lo rattristiamo

((())())

quanti ()?

     ()
((())  )

1. rimuoviamo e aggiungiamo un 1 all'inizio

(1,(()))

questo ha un elenco al suo interno

(())

contare

 ()
(  )

rimuovere e aggiungere il conteggio

(1)

quindi lo rimettiamo nel suo elenco

(1,(1))

quindi lo rimettiamo nel suo elenco

(3,(1,(1)))

fatto

Questo è code-golf , quindi più breve è meglio

Pyth , 13 byte

L+]/bYyM-b]Yy

Suite di test .

Come funziona

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 byte

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

accetta input come elenco di elenchi.

Provalo online!

Brachylog , 21 byte

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

Provalo online!

Mathematica, 42 byte

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

Evita la ricorsione esplicita usando //@( MapAll) che mappa una funzione su ogni nodo di un albero. Questo significa anche che le funzioni sono eseguite dalle foglie verso l'alto. Tuttavia, verrà anche applicato a {}cui si trasforma {0}nel processo. Ecco perché contiamo e rimuoviamo {0}invece {}.

Retina , 42 byte

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

Provalo online!

Clojure, 59 byte

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

Non molto diverso dalla risposta CommonLisp . È counte removesembra accettare un costrutto un po 'più bello, qui ho dovuto usare i set.

In realtà , 12 byte

;[]@c@;░Q£Mo

Provalo online!

Prende l'input come un elenco di parentesi quadre separate da virgola con parentesi esterne esplicite.

Spiegazione:

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

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

Provalo online!

Gelatina , 10 byte

Tị߀;@ċ“”$

Provalo online!

Accetta input come elenco di elenchi di elenchi ...

Ovviamente utilizza l'algoritmo utilizzato dalle altre risposte. ;)

Haskell , 102 byte

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

Provalo online!

Poiché Haskell è tipizzato in modo rigoroso, non esistono elenchi nidificati in modo arbitrario. Come rimedio data L=I Int|T[L]deriving Showdichiara liste nidificate ad albero con Ints o liste vuote come foglie.

Ingresso è come nel secondo formato esempio, con un costruttore aggiuntivo Tprima di ogni parentesi aperta: T[T[T[]],T[],T[T[]]]. Lo stesso vale per l'output, con ogni numero preceduto da un costruttore I. La funzione fesegue la tristezza .

Uscite per i casi di test:

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 byte

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

dimostrazione

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>