¿Son iguales los dos conjuntos?

9

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

code-golf  decision-problem  balanced-string 
— Liam
fuente
¿Puede un idioma con un tipo de conjunto anidable simplemente verificar la igualdad?
— xnor
@xnor Built-ins debería ser un juego justo, sí
— Liam
1
@Dennis, a pesar de que este es un desafío de "cadena equilibrada", nunca lo pensé realmente como un desafío de análisis. Pero, ahora que lo pienso, al suponer que todas las entradas son válidas, lo he convertido en un desafío de análisis. Entonces creo que tienes razón. Los idiomas suficientes probablemente tengan la idea de una lista no ordenada que trivializaría esto.
— Liam
1
Estaré bien con cualquier decisión que tomes. Personalmente, si bien creo que el uso de conjuntos de alguna manera puede ser creativo sin trivializar el desafío (como mi respuesta de Julia, que convierte recursivamente una matriz anidada en un conjunto anidado), lo que permite que los conjuntos anidados como entrada hagan que todo sea demasiado simple ( ==en Julia, 2 bytes; frozenset.__eq__en Python, 16 bytes; etc.).
— Dennis
8
See the comments for an explanation. Por favor no hagas esto. Los comentarios son volátiles y desaparecen muy fácilmente, por lo que el sutff importante entra en el cuerpo del mensaje
— gato

Respuestas:

3

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
— Fatalizar
fuente
2

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.

— Martin Ender
fuente
2

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 [[],[[]]].

— Neil
fuente
No utiliza la recursividad, por lo que puede hacerla anónima
— Bálint
¿Por qué está eso 0+ahí?
— Bálint
@ Bálint Porque sin el 0+y +1todo lo que obtendría son comas.
— Neil
@ Bálint No sé por qué olvidé eliminar el f=, no lo incluí en el conteo de bytes y soy demasiado vago para editar la publicación solo por eso.
— Neil
2

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
— Lynn
fuente
g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]])vuelve False, pero los conjuntos son iguales. Eso debería solucionarse mediante mapeo antes de ordenar.
— Dennis
2

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.

— Cadena no relacionada
fuente
Y ahora necesito dormir
— Cadena no relacionada
2

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.

— Adán
fuente
1

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!

— Dennis
fuente
1

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.

— Adán
fuente
1

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.
— Cadena no relacionada
fuente
0

𝔼𝕊𝕄𝕚𝕟, 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
— Mama Fun Roll
fuente
0

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
— Lynn
fuente
Por interés, ¿por qué necesita definir su propio tipo de lista aquí? (¿Están ==y <no están definidos de manera predeterminada para las listas?)
1
el tipo de datos es recursivo: lo defino Scomo una lista (incluida L) de Ses. Haskell no tiene un tipo incorporado que pueda representar listas de listas de listas de ...
— Lynn
0

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!

— bb94
fuente
Algunas cosas: no necesita el espacio después de los argumentos para el bloque de código, a menudo es más corto usar la $^sintaxis en su lugar, y no creo que la []entrada funcione, ya que todo, [[]],[[[]]],[[[[]]]]etc. evalúa[]
— Jo King,
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.