{}est l'ensemble vide. Vous pouvez utiliser ()ou []si vous choisissez.

Nous n'allons pas définir rigoureusement "set", mais les sets satisfont tous aux propriétés suivantes:

Les ensembles suivent la structure mathématique habituelle. Voici quelques points importants:

• Les ensembles ne sont pas commandés.
• Aucun ensemble ne se contient.
• Les éléments sont dans un ensemble ou non, c'est booléen. Par conséquent, les éléments d'ensemble ne peuvent pas avoir de multiplicités (c'est-à-dire qu'un élément ne peut pas être dans un ensemble plusieurs fois.)
• Les éléments d'un ensemble sont également des ensembles et {}sont le seul élément primitif.

Tâche

Écrivez un programme / une fonction qui détermine si deux ensembles sont égaux.

Contribution

Deux ensembles valides via stdin ou argument de fonction. Le format d'entrée est lâche dans des limites raisonnables.

Certaines entrées valides sont:

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

Entrées non valides:

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

Production

Une valeur vraie si les entrées sont égales, faux sinon.

Cas de test

Votre soumission doit répondre correctement pour toutes les entrées valides, pas seulement pour les cas de test. Ceux-ci peuvent être mis à jour à tout moment.

Vérité:

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

Falsy:

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

Notation

code-golf

Règles supplémentaires

Une règle supplémentaire a été ajoutée interdisant complètement les types itérables non ordonnés. Ils sont trop courants et banalisent beaucoup trop ce défi. N'hésitez pas à laisser en place les réponses qui violent cela, veuillez simplement indiquer qu'elles ont été apportées avant le changement de règle.

CJam, 11 octets

q']/"]$"*~=

Essayez-le ici.

CJam, 13 octets

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

Essayez-le ici.

Gelée , 6 octets

߀Ṣ
ÇE

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

Ç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 octets

{p:1a.}.

Cela attend des crochets en entrée et en sortie.

Par exemple:

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

Explication

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

LSyMbqyEy

Format d'entrée: utilisez []au lieu de {}.

Suite de tests

Mathematica, 16 octets

Equal@@Sort//@#&

Une fonction sans nom qui attend une liste contenant les deux ensembles, par exemple

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

Nous utilisons //@( MapAll) pour trier les ensembles à chaque niveau, puis affirmons que les résultats sont égaux.

JavaScript (ES6), 42 octets

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

Accepte l'entrée en utilisant []par exemple s f([[],[[]]],[[[]],[]]). Fonctionne en convertissant les tableaux en chaînes, puis en les triant de l'intérieur vers l'extérieur. 0et 1sont utilisés parce qu'ils sont plus courtes que '['et ']', ainsi , par exemple g([[[]],[]])est ce 001,00111qui représente [[],[[]]].

Python 2, 49 octets

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

Par exemple, appeler la fonction anonyme g:

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

Prolog (SWI) , 37 octets

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

Essayez-le en ligne!

Prend les entrées sous forme de listes imbriquées, c'est-à-dire avec des crochets au lieu d'accolades. À l'origine, c'était le cas X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., mais j'ai ensuite essayé de traduire la réponse Bratalylog v1 de Fatalize et il s'est avéré 3 octets plus court.

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)

Il peut en fait gérer les accolades à la place, pour 23 octets supplémentaires:

Prolog (SWI) , 60 octets

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

Essayez-le en ligne!

*convertit ici un terme (non vide, d'où le X=Y;) accolade sur son côté droit en une liste des éléments du terme, puis le trie sur son côté gauche.

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

Étant donné que les deux arguments +sont *déjà en cours, mettre un sortin *économise 7 octets par rapport à l'utilisation de permutationin +.

Et enfin, voici une version qui gère les listes d'entrée ayant éventuellement des éléments en double, c'est ce qui m'a inspiré pour écrire une solution dans Prolog pour commencer:

Prolog (SWI) , 57 octets

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

Essayez-le en ligne!

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.

Essentiellement, X/Ydéclare que X est un sous-ensemble de Y, en déclarant que pour chaque élément de X, il y a un élément égal de Y, X/Y,Y/Xdéclare donc que X et Y sont des ensembles égaux.

APL (NARS2000), 4 octets

≡⍦

⍦est l'opérateur multiset, qui modifie les fonctions pour traiter leurs arguments comme des ensembles au lieu de listes
≡est la fonction d'équivalence, qui retourne un booléen indiquant si les arguments sont complètement équivalents en valeur et en forme

Concernant la règle supplémentaire: Notez que cette réponse n'utilise aucun type de données d'ensemble non ordonné, mais uniquement des listes normales (qui peuvent contenir plusieurs éléments identiques). Il les traite simplement comme des ensembles.

Le nombre d'octets est 4 car le NARS2000 utilise exclusivement UCS-2.

Julia, 36 35 32 octets

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

L'entrée est un tableau imbriqué, soit la {}syntaxe (obsolète), soit Any[].

Essayez-le en ligne!

SETL, 1 octet

=

Prend les ensembles comme arguments gauche et droit.

Notez que cela n'adhère PAS à la règle ajoutée qui interdit les types de données définis non ordonnés.

Brachylog v2, 3 octets

p↰ᵐ

Essayez-le en ligne!

Prend un ensemble via la variable d'entrée et l'autre ensemble via la variable de sortie. Réussit si les ensembles sont égaux et échoue s'ils ne le sont pas.

Comme ma réponse Prolog principale, une traduction de la réponse Brachylog v1 de Fatalize (qui, je pense, pourrait être utilisée pour jouer au golf 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 caractères / 9 octets

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

Explication

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

Haskell, 77 octets

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 octets

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

Prend entrée avec [].

Essayez-le en ligne!

Wolfram Language (Mathematica) , 20 octets

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

Essayez-le en ligne!

Fonction pure qui prend chaque ensemble en argument.