In dieser Herausforderung müssen Sie eine Liste von Listen in ein einfacheres Listenformat umwandeln.

Diese Herausforderung basiert auf meinem Sadflak-Parser. In meinem Sadflak-Parser wurden alle () entfernt und durch die Summe der () am Anfang der Liste ersetzt, damit das Programm schneller ausgeführt wird.

Um eine Sad-List zu parsen, müssen Sie dies tun (Python-Implementierungssache, verwendet ein Tupel von Tupeln):

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

Dies ist eine rekursive Funktion. Starten Sie für eine Liste eine neue Liste, beginnend mit der Nummer () aus der Listeneingabe. Der Rest dieser Liste besteht aus Versionen aller Listen, die nicht () aus der Listeneingabe waren. Gib die Liste zurück.

Eingang:

Sie können Eingaben in verschiedenen Formaten vornehmen:

• Sie können es als Liste nehmen
• Sie können es als Tupel nehmen
• Sie können es als Zeichenfolge nehmen

Wenn Sie es als eine Schnur nehmen, sollten Sie einige Klammern verwenden, wie sie in Brain-Flak erscheinen. Sie dürfen die Zeichen 1 und 2 nicht verwenden

Sei einfach vernünftig

Die Eingabe befindet sich immer in einer Liste, aber Ihr Programm nimmt möglicherweise eine implizite Listenebene außerhalb der Eingabe an, dh () () () = (() () ()), oder es entscheidet sich möglicherweise dagegen. Beispiele werden mit expliziter externer Liste sein

Ausgabe:

kann list oder tuple oder string sein, oder was auch immer. Sie können jedes vernünftige Ausgabeformat verwenden, genau wie der Metakonsens.

Beispiel:

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

Beachten Sie, dass die Eingabe nicht streng ist. Diese Eingaben könnten sein:

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

oder ein anderes vernünftiges Format

erklärter Testfall:

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

um dies zu "sadifizieren", zählen wir zuerst die Anzahl der ()

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

3. Dann entfernen wir diese und fügen am Anfang eine 3 hinzu

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

Es gibt eine Liste in dieser Liste. Wir bedauern dies

((())())

wie viele ()?

     ()
((())  )

1. Wir entfernen und fügen zu Beginn eine 1 hinzu

(1,(()))

Das hat eine Liste

(())

Anzahl

 ()
(  )

entfernen Sie und addieren Sie Zählung

(1)

dann setzen wir dies wieder in seine Liste

(1,(1))

dann setzen wir dies wieder in seine Liste

(3,(1,(1)))

erledigt

Das ist Code-Golf , also ist kürzer besser

Pyth , 13 Bytes

L+]/bYyM-b]Yy

Testsuite .

Wie es funktioniert

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

Eingaben als Listenliste übernehmen.

Probieren Sie es online!

Brachylog , 21 Bytes

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

Probieren Sie es online!

Mathematica, 42 Bytes

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

Vermeidet eine explizite Rekursion durch Verwendung von //@( MapAll), das eine Funktion über jeden Knoten in einem Baum abbildet. Dies bedeutet auch, dass die Funktionen von den Blättern aufwärts ausgeführt werden. Es wird aber auch angewendet, in {}was sich dabei verwandelt {0}. Deshalb zählen und entfernen wir {0}stattdessen {}.

Netzhaut , 42 Bytes

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

Probieren Sie es online!

Clojure, 59 Bytes

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

Nicht viel anders als die CommonLisp- Antwort. Es ist countund removescheint ein etwas schöneres Konstrukt zu akzeptieren, hier musste ich Sets verwenden.

Eigentlich 12 Bytes

;[]@c@;░Q£Mo

Probieren Sie es online!

Übernimmt die Eingabe als durch Kommas getrennte Liste mit eckigen Klammern und expliziten äußeren Klammern.

Erläuterung:

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

Probieren Sie es online!

Gelee , 10 Bytes

Tị߀;@ċ“”$

Probieren Sie es online!

Übernimmt Eingaben als Liste von Listen von Listen ...

Natürlich wird der Algorithmus verwendet, den die anderen Antworten verwenden. ;)

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

Probieren Sie es online!

Da Haskell streng typisiert ist, gibt es keine willkürlich verschachtelten Listen. Als Heilmitteldata L=I Int|T[L]deriving Show deklariert man baumartig verschachtelte Listen mit entweder Ints oder leeren Listen als Blätter.

Eingegeben wird , wie im zweiten Beispiel Format, mit einem zusätzlichen Konstruktor Tvor jeder Öffnung Brace: T[T[T[]],T[],T[T[]]]. Gleiches gilt für die Ausgabe, wobei jeder Zahl ein Konstruktor vorangestellt ist I. Funktion fführt die Trauer aus .

Ausgaben für die Testfälle:

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

Golf gespielt:

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>