Analysieren Sie eine Liste von Listen in eine Sad-List

12

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 , also ist kürzer besser

Zerstörbare Zitrone
quelle
Beachten Sie, dass im eigentlichen Sad-Flak-Parser die Zahl () tatsächlich das zweite Element der Liste ist und das erste Element der Index des Befehls ist
Destructible Lemon
Gut altes JavaScript for... in, ich erinnere mich, warum Sie es nie verwenden: Geige
Stephen
Ich denke ((((())())())(())()) = [1, [1, [1, [1]], [1]]sollte sein ((((())())())(())()) = [1, [1, [1, [1]]], [1]].
Renzo

Antworten:

4

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
Undichte Nonne
quelle
Sie können zuerst entfernen ].
Erik der Outgolfer
3

CommonLisp, 49 Bytes

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

Eingaben als Listenliste übernehmen.

Probieren Sie es online!

Renzo
quelle
2

Brachylog , 21 Bytes

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

Probieren Sie es online!

Undichte Nonne
quelle
Bytes und Zeichen sind nicht gleichbedeutend. Unter Verwendung von UTF-8 würde dies 33 Bytes beanspruchen, obwohl es nur 21 Zeichen sind.
Samadi
1
@Samadi Brachylog verwendet eine eigene Codepage , die gemäß dieser Metaantwort zulässig ist .
Undichte Nonne
Ah ich sehe. Ich war etwas verwirrt. Danke fürs klarstellen!
Samadi
@ Samadi Kein Problem, diese Frage wird ständig gestellt.
Undichte Nonne
2

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 {}.

Martin Ender
quelle
2

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.

NikoNyrh
quelle
2

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
Mego
quelle
2

Python 2 , 69 46 45 Bytes

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

Probieren Sie es online!

ovs
quelle
Ich denke, Sie müssen f=Ihrem bytecount etwas hinzufügen , da Sie die Funktion f verwenden und eine andere Benennung Ihre Lösung
Leo,
@Leo Du hast recht.
Ovs
1

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

Erik der Outgolfer
quelle
Das sind keine 10 Bytes. Es sind 10 Zeichen . Die Anzahl der Bytes hängt von der verwendeten Codierung ab.
Samadi
2
@Samadi Nein, Jelly hat einen speziellen Zeichensatz, der standardmäßig eingestellt ist, und kann diese Zeichen jeweils als ein Byte darstellen. Sehen Sie hier .
Adám
Aha. Danke für die Klarstellung!
Samadi
1

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]
Laikoni
quelle
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

HonoredMule
quelle