{}ist die leere Menge. Sie können verwenden ()oder []wenn Sie möchten.

Wir werden "set" nicht rigoros definieren, aber alle Sets erfüllen die folgenden Eigenschaften:

Mengen folgen der üblichen mathematischen Struktur. Hier sind einige wichtige Punkte:

• Sets werden nicht bestellt.
• Kein Satz enthält sich selbst.
• Elemente sind entweder in einer Menge oder nicht, dies ist boolesch. Daher können Mengenelemente keine Multiplizitäten haben (dh ein Element kann nicht mehrmals in einer Menge enthalten sein.)
• Elemente einer Menge sind ebenfalls Mengen und {}sind das einzige primitive Element.

Aufgabe

Schreiben Sie ein Programm / eine Funktion, die bestimmt, ob zwei Sätze gleich sind.

Eingang

Zwei gültige Mengen über stdin oder Funktionsargument. Das Eingabeformat ist im Rahmen der Vernunft locker.

Einige gültige Eingaben sind:

{} {{}}
{{},{{}}} {{{{{},{{}}}}}}
{{},{{},{{}}}} {{{},{{}}},{{{{{},{{}}}}}}}

Ungültige Eingaben:

{{} {}              Brackets will always be balanced.
{{},{}} {}          Set contains the same element twice

Ausgabe

Ein wahrer Wert, wenn die Eingaben gleich sind, andernfalls falsch.

Testfälle

Ihre Einreichung sollte für alle gültigen Eingaben korrekt sein, nicht nur für die Testfälle. Diese können jederzeit aktualisiert werden.

Wahrheit:

{} {}
{{},{{}}} {{{}},{}}
{{},{{},{{{}},{}}}} {{{{},{{}}},{}},{}}

Falsch:

{} {{}}
{{},{{},{{{}},{}}}} {{{{}}},{},{{}}}
{{},{{}},{{{}}},{{},{{}}}} {}

Wertung

Code-Golf

Zusätzliche Regeln

Es wurde eine zusätzliche Regel hinzugefügt, die ungeordnete iterierbare Typen insgesamt verbietet. Sie sind zu häufig und trivialisieren diese Herausforderung viel zu sehr. Fühlen Sie sich frei, Antworten zu hinterlassen, die dies verletzen. Bitte geben Sie einfach an, dass sie vor der Regeländerung gemacht wurden.

CJam, 11 Bytes

q']/"]$"*~=

Probieren Sie es hier aus.

CJam, 13 Bytes

q~L{{j}%$}j:=

Probieren Sie es hier aus.

Gelee , 6 Bytes

߀Ṣ
ÇE

Probieren Sie es online aus! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ÇE   Main link. Argument: [s, t] (pair of set arrays)

Ç    Apply the helper link to [s, t].
 E   Check if the elements of the resulting pair are equal.


߀Ṣ  Helper link. Argument: u (set array)

߀   Recursively map this link over u.
  Ṣ  Sort the result.

Brachylog , 8 Bytes

{p:1a.}.

Dies erwartet Klammern in Eingabe und Ausgabe.

Beispielsweise:

?- run_from_atom('{p:1a.}.', [[]:[[]]], [[[]]:[]]).
true .

Erläuterung

{     }.   True if the predicate inside brackets is true with input Input and output Output

 p          Unify an implicit variable with a permutation of Input
  :1a       Apply this same predicate to each element of that implicit variable
     .      True if Output can be unified with the resulting list

Pyth, 9 Bytes

LSyMbqyEy

Eingabeformat: Verwenden Sie []anstelle von {}.

Testsuite

Mathematica, 16 Bytes

Equal@@Sort//@#&

Eine unbenannte Funktion, die eine Liste erwartet, die beide Mengen enthält, z

Equal@@Sort//@#& @ {{{}, {{}}}, {{{}}, {}}}

Wir verwenden //@( MapAll), um die Mengen auf jeder Ebene zu sortieren und dann zu behaupten, dass die Ergebnisse gleich sind.

JavaScript (ES6), 42 Byte

f=(a,b,g=a=>0+a.map(g).sort()+1)=>g(a)==g(b)

Akzeptiert Eingaben mit []s z f([[],[[]]],[[[]],[]]). Konvertiert die Arrays in Strings und sortiert sie dann von innen nach außen. 0und 1werden verwendet , weil sie kürzer als '['und ']', so zum Beispiel g([[[]],[]])ist 001,00111die darstellt [[],[[]]].

Python 2, 49 Bytes

f=lambda x:sorted(map(f,x))
lambda a,b:f(a)==f(b)

Beispiel: Aufruf der anonymen Funktion g:

>>> g( [[],[[]]] , [[[]],[]] )
True

Prolog (SWI) , 37 Bytes

X+Y:-permutation(X,Z),maplist(+,Z,Y).

Probieren Sie es online aus!

Nimmt Eingaben als verschachtelte Listen auf, dh mit eckigen Klammern anstelle von geschweiften Klammern. Ursprünglich war dies der X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N).Fall, aber dann habe ich versucht, die Antwort von Fatalize auf Brachylog v1 zu übersetzen, und es stellte sich heraus, dass sie 3 Byte kürzer war.

X+Y :-                    X+Y succeeds when
    permutation(X, Z),    for some permutation Z of X
    maplist(+, Z, Y).     + succeeds for every pair in Z zipped with Y.
                          (where maplist will succeed without the recursive call to + for
                          two empty lists, and fail if the lists have different lengths)

Es kann stattdessen geschweifte Klammern verarbeiten, für 23 weitere Bytes:

Prolog (SWI) , 60 Bytes

{A}*C:-A=..[,|B],sort(B,C).
X+Y:-X=Y;X*M,Y*N,maplist(+,M,N).

Probieren Sie es online aus!

*Hier wird ein (nicht leerer, daher der X=Y;) Klammerbegriff auf seiner rechten Seite in eine Liste der Elemente des Begriffs konvertiert und dann auf seiner linken Seite sortiert.

{A}*C :-            X*C succeeds when X is the brace term containing A
    A =.. [,|B],    where A is a comma-tuple and B is a list of its elements,
    sort(B, C).     and C is B sorted.

Da beide Argumente bereits +durchlaufen werden *, spart das Einfügen von sortin *7 Bytes gegenüber der Verwendungpermutation in +.

Und schließlich ist hier eine Version, die die Eingabelisten behandelt, die möglicherweise doppelte Elemente enthalten. Dies hat mich dazu inspiriert, zunächst eine Lösung in Prolog zu schreiben:

Prolog (SWI) , 57 Bytes

X+Y:-X/Y,Y/X.
X/Y:-maplist(-(Y),X).
Y-E:-member(F,Y),E+F.

Probieren Sie es online aus!

X+Y :-                   X+Y succeeds when
    X/Y, Y/X.            X/Y and Y/X succeed.
X/Y :-                   X/Y succeeds when
    maplist(-(Y), X).    for every element E of X, Y-E succeeds
                         (or when X is empty).
Y-E :-                   Y-E succeeds when
    member(F, Y),        there exists some element F of Y
    E+F.                 such that E+F succeeds.

X/YErklärt im Wesentlichen, dass X eine Teilmenge von Y ist, indem deklariert wird, dass für jedes Element von X ein gleiches Element von Y vorhanden ist, X/Y,Y/Xund dass X und Y gleiche Mengen sind.

APL (NARS2000), 4 Bytes

≡⍦

⍦ ist der Multiset-Operator, der Funktionen so ändert, dass ihre Argumente als Mengen anstelle von Listen behandelt werden
≡ ist die Äquivalenzfunktion, die einen Booleschen Wert zurückgibt, der angibt, ob die Argumente in Wert und Form vollständig äquivalent sind

Zu der zusätzlichen Regel: Beachten Sie, dass diese Antwort keinen ungeordneten festgelegten Datentyp verwendet, sondern nur normale Listen (die mehrere identische Elemente enthalten können). Es behandelt nur sie nur als Sets.

Die Byteanzahl beträgt 4, da NARS2000 ausschließlich UCS-2 verwendet.

Julia, 36 35 32 Bytes

u*v=(sort(u.*v)...)
s%t=s*s==t*t

Die Eingabe ist ein verschachteltes Array, entweder mit der (veralteten) {}Syntax oder Any[].

Probieren Sie es online aus!

SETL, 1 Byte

=

Nimmt Sätze als linkes und rechtes Argument.

Beachten Sie, dass dies NICHT der hinzugefügten Regel entspricht, die ungeordnete festgelegte Datentypen verbietet.

Brachylog v2, 3 Bytes

p↰ᵐ

Probieren Sie es online aus!

Nimmt einen Satz durch die Eingangsvariable und den anderen Satz durch die Ausgangsvariable. Erfolgreich, wenn die Sätze gleich sind, und fehlgeschlagen, wenn sie nicht gleich sind.

Wie meine Hauptantwort auf Prolog, eine Übersetzung von Fatalizes Brachylog v1-Antwort (auf die man meiner Meinung nach zurückgreifen könnte p:0a?).

       The input
p      can be re-ordered so that
 ↰     when this predicate is applied again to
  ᵐ    all of its elements,
       it is the output.

𝔼𝕊𝕄𝕚𝕟 7 Zeichen / 9 Bytes

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

Erläuterung

         // implicit: î=input1,í=input2
  Ꞩî,Ꞩí // apply the Set method to both inputs
Ѩƾ      // check if the Sets are equal
        // implicit output

Haskell, 77 Bytes

import Data.List
data S=L[S]deriving(Eq,Ord)
f(L x)=L$sort$f<$>x
a!b=f a==f b

Perl 6 , 55 Bytes

my&f=->\a,\b {a==b&&all map {f(|$_)},(a.sort Z,b.sort)}

Nimmt Eingabe mit [] .

Probieren Sie es online aus!

Wolfram-Sprache (Mathematica) , 20 Bytes

Sort//@#==Sort//@#2&

Probieren Sie es online aus!

Reine Funktion, die jeden Satz als Argument verwendet.