W tym wyzwaniu musisz przeanalizować listę list w prostszym formacie listy.

To wyzwanie opiera się na moim parserze Sadflak. W moim parserze sadflak usunął wszystkie (), zastąpione sumą () na początku listy, aby program działał szybciej.

Aby parsować do Sad-List, musisz to zrobić (implementacja Pythona, używa krotki krotek):

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

To jest funkcja rekurencyjna. Aby uzyskać listę, rozpocznij nową listę, zaczynając od liczby () z danych wejściowych listy, a następnie reszta tej listy to wersje list smutnych każdej listy, która nie była () z danych wejściowych listy, w kolejności. zwróć listę.

Wejście:

możesz wziąć dane wejściowe w kilku różnych formatach:

• możesz wziąć to jako listę
• możesz wziąć to jako krotkę
• możesz wziąć to jako ciąg

jeśli weźmiesz go jako ciąg, powinieneś użyć jakiegoś zestawu nawiasów, które pojawiają się w trzepoczeniu mózgu. nie możesz używać znaków 1 i 2

po prostu bądź rozsądny

Dane wejściowe zawsze będą znajdować się na jednej liście, ale twój program może założyć niejawną warstwę listy poza danymi wejściowymi, tj. () () () = (() () ()), Lub może tego nie robić. Przykłady będą z jawną listą zewnętrzną

wynik:

może być listą, krotką, łańcuchem lub czymkolwiek. możesz użyć dowolnego rozsądnego formatu wyjściowego, podobnie jak meta konsensus.

Przykład:

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

zauważ, że dane wejściowe nie są ścisłe. te dane wejściowe mogą być:

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

lub jakiś inny rozsądny format

wyjaśniony przypadek testowy:

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

aby to „usankcjonować”, najpierw liczymy liczbę ()

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

3. następnie usuwamy je i dodajemy 3 na początku

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

na tej liście jest jedna lista. smucimy to

((())())

ile ()?

     ()
((())  )

1. usuwamy i dodajemy 1 na początku

(1,(()))

zawiera jedną listę

(())

liczyć

 ()
(  )

usuń i dodaj liczbę

(1)

następnie umieszczamy to z powrotem na liście

(1,(1))

następnie umieszczamy to z powrotem na liście

(3,(1,(1)))

gotowy

To jest golf golfowy , więc krótszy jest lepszy

Pyth , 13 bajtów

L+]/bYyM-b]Yy

Zestaw testowy .

Jak to działa

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 bajtów

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

weź dane jako listę list.

Wypróbuj online!

Brachylog , 21 bajtów

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

Wypróbuj online!

Mathematica, 42 bajty

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

Unika jawnej rekurencji za pomocą //@( MapAll), która mapuje funkcję na każdym węźle w drzewie. Oznacza to również, że funkcje są wykonywane od liści w górę. Jednak zostanie również zastosowany, w {}który zostanie przekształcony {0}. Dlatego {0}zamiast tego liczymy i usuwamy {}.

Siatkówka , 42 bajty

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

Wypróbuj online!

Clojure, 59 bajtów

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

Niewiele różni się od odpowiedzi CommonLisp . Jego counti removezdają się akceptować konstrukt nieco ładniejszy, tutaj musiałem użyć sety.

Właściwie 12 bajtów

;[]@c@;░Q£Mo

Wypróbuj online!

Pobiera dane wejściowe jako rozdzieloną przecinkami listę nawiasów kwadratowych z wyraźnymi nawiasami zewnętrznymi.

Wyjaśnienie:

;[]@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 bajtów

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

Wypróbuj online!

Galaretka , 10 bajtów

Tị߀;@ċ“”$

Wypróbuj online!

Pobiera dane wejściowe jako listę list list ...

Oczywiście używa algorytmu, którego używają inne odpowiedzi. ;)

Haskell , 102 bajty

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

Wypróbuj online!

Ponieważ Haskell jest ściśle wpisany, nie ma arbitralnie zagnieżdżonych list. Jako środek zaradczy data L=I Int|T[L]deriving Showdeklaruje drzewiaste listy zagnieżdżone z Ints lub pustymi listami jako liście.

Wejście jest jak w drugim przykładzie formacie, z dodatkowym konstruktora Tprzed każdym nawiasu otwierającego: T[T[T[]],T[],T[T[]]]. To samo dotyczy danych wyjściowych, przy czym każda liczba jest poprzedzona konstruktorem I. Funkcja fwykonuje zasmucenie .

Dane wyjściowe dla przypadków testowych:

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 bajtów

Gra w golfa:

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

Nie golfowany:

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

Próbny

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>