{}Es el conjunto vacío. Puede usar ()o []si lo desea.

No vamos a definir rigurosamente "conjunto", pero todos los conjuntos satisfacen las siguientes propiedades:

Los conjuntos siguen la estructura matemática habitual. Aquí hay algunos puntos importantes:

• Los conjuntos no están ordenados.
• Ningún conjunto se contiene a sí mismo.
• Los elementos están en un conjunto o no, esto es booleano. Por lo tanto, los elementos del conjunto no pueden tener multiplicidades (es decir, un elemento no puede estar en un conjunto varias veces).
• Los elementos de un conjunto también son conjuntos y {}es el único elemento primitivo.

Tarea

Escriba un programa / función que determine si dos conjuntos son iguales.

Entrada

Dos conjuntos válidos a través de stdin o argumento de función. El formato de entrada está suelto dentro de lo razonable.

Algunas entradas válidas son:

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

Entradas inválidas:

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

Salida

Un valor verdadero si las entradas son iguales, de lo contrario, falso.

Casos de prueba

Su envío debe responder correctamente para todas las entradas válidas, no solo para los casos de prueba. Estos pueden actualizarse en cualquier momento.

Verdad:

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

Falsy

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

Puntuación

código-golf

Reglas Adicionales

Se ha agregado una regla adicional que prohíbe completamente los tipos iterables no ordenados. Son demasiado comunes y trivializan demasiado este desafío. Siéntase libre de dejar respuestas que violen esto en su lugar, solo indique que se hicieron antes del cambio de regla.

CJam, 11 bytes

q']/"]$"*~=

Pruébalo aquí.

CJam, 13 bytes

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

Pruébalo aquí.

Jalea , 6 bytes

߀Ṣ
ÇE

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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

Esto espera corchetes en entrada y salida.

Por ejemplo:

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

Explicación

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

Formato de entrada: use en []lugar de {}.

Banco de pruebas

Mathematica, 16 bytes

Equal@@Sort//@#&

Una función sin nombre que espera una lista que contenga ambos conjuntos, por ej.

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

Usamos //@( MapAll) para ordenar los conjuntos en cada nivel y luego afirmar que los resultados son iguales.

JavaScript (ES6), 42 bytes

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

Acepta entrada usando []s eg f([[],[[]]],[[[]],[]]). Funciona convirtiendo las matrices en cadenas y luego clasificándolas de adentro hacia afuera. 0y 1se utilizan porque son más cortos que '['y ']', así por ejemplo, g([[[]],[]])es 001,00111lo que representa [[],[[]]].

Python 2, 49 bytes

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

Por ejemplo, llamando a la función anónima g:

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

Prólogo (SWI) , 37 bytes

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

Pruébalo en línea!

Toma la entrada como listas anidadas, es decir, con corchetes en lugar de llaves. Originalmente, esto era X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., pero luego intenté traducir la respuesta Brachylog v1 de Fatalize y resultó 3 bytes más corto.

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)

En realidad, puede manejar llaves en lugar de 23 bytes más:

Prólogo (SWI) , 60 bytes

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

Pruébalo en línea!

*aquí convierte un X=Y;término de llave (no vacío, por lo tanto ) en su lado derecho a una lista de los elementos del término y luego lo ordena a su lado izquierdo.

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

Dado que ambos argumentos ya +están pasando *, poner un sortin *ahorra 7 bytes sobre el uso de permutationin +.

Y finalmente, aquí hay una versión que maneja las listas de entrada que posiblemente tengan elementos duplicados, que es lo que me inspiró a escribir una solución en Prolog para comenzar:

Prólogo (SWI) , 57 bytes

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

Pruébalo en línea!

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.

Esencialmente, X/Ydeclara que X es un subconjunto de Y, al declarar que para cada elemento de X, hay un elemento igual de Y, por lo X/Y,Y/Xque declara que X e Y son conjuntos iguales.

APL (NARS2000), 4 bytes

≡⍦

⍦es el operador multiset, que modifica las funciones para tratar sus argumentos como conjuntos en lugar de listas,
≡es la función de equivalencia, que devuelve un valor booleano que indica si los argumentos son completamente equivalentes en valor y forma

Con respecto a la regla adicional: tenga en cuenta que esta respuesta no utiliza ningún tipo de datos de conjunto desordenado, sino solo listas normales (que pueden contener múltiples elementos idénticos). Simplemente los trata como conjuntos.

El recuento de bytes es 4 porque NARS2000 usa UCS-2 exclusivamente.

Julia, 36 35 32 bytes

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

La entrada es una matriz anidada, ya sea la {}sintaxis (en desuso) o Any[].

Pruébalo en línea!

SETL, 1 byte

=

Toma conjuntos como argumentos izquierdo y derecho.

Tenga en cuenta que esto NO cumple con la regla agregada que prohíbe tipos de datos de conjuntos desordenados.

Brachylog v2, 3 bytes

p↰ᵐ

Pruébalo en línea!

Toma un conjunto a través de la variable de entrada y el otro conjunto a través de la variable de salida. Tiene éxito si los conjuntos son iguales y falla si no lo son.

Al igual que mi respuesta principal de Prolog, una traducción de la respuesta Brachylog v1 de Fatalize (que creo que se podría resumir 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 caracteres / 9 bytes

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

Explicación

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

Toma entrada con [].

Pruébalo en línea!

Wolfram Language (Mathematica) , 20 bytes

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

Pruébalo en línea!

Función pura que toma cada conjunto como argumento.