9

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

code-golf decision-problem balanced-string

— Liam
source

Une langue avec un type d'ensemble emboîtable peut-elle simplement vérifier l'égalité?

— xnor

@xnor Built-ins devrait être un jeu équitable, oui

— Liam

1

@ Dennis bien, même si c'est un défi "à cordes équilibrées", je ne l'ai jamais vraiment considéré comme un défi d'analyse. Mais, maintenant que j'y pense, en supposant que toutes les entrées sont valides, j'en ai en quelque sorte fait un défi d'analyse. Je pense donc que vous avez raison. Assez de langues ont probablement l'idée d'une liste non ordonnée qui banaliserait cela.

— Liam

1

Je serai d'accord avec n'importe quelle décision que vous prendrez. Personnellement, même si je pense que l'utilisation d'ensembles peut être créative sans banaliser le défi (comme ma réponse Julia, qui convertit récursivement un tableau imbriqué en un ensemble imbriqué), autoriser les ensembles imbriqués en entrée rend le tout un peu trop simple ( ==dans Julia, 2 octets; frozenset.__eq__en Python, 16 octets; etc.).

— Dennis

8

See the comments for an explanation. Veuillez ne pas faire ça. Les commentaires sont volatils et disparaissent très facilement, donc le sutff important passe dans le corps du post

— cat

4

CJam, 11 octets

q']/"]$"*~=

Essayez-le ici.

CJam, 13 octets

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

Essayez-le ici.

— jimmy23013
source

4

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.

— Dennis
source

3

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

— Fatalize
source

2

Pyth, 9 octets

LSyMbqyEy

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

Suite de tests

— Anders Kaseorg
source

2

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.

— Martin Ender
source

2

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

— Neil
source

Vous n'utilisez pas la récursivité, vous pouvez donc la rendre anonyme

— Bálint

Pourquoi est-ce 0+là?

— Bálint

@ Bálint Parce que sans 0+et +1tout ce que j'obtiendrais serait des virgules.

— Neil

@ Bálint Je ne sais pas pourquoi j'ai oublié de supprimer le f=, je ne l'ai pas inclus dans le nombre d'octets et je suis trop paresseux pour éditer le message juste pour ça.

— Neil

2

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

— Lynn
source

g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]])renvoie False, mais les ensembles sont égaux. Cela devrait être corrigé par mappage avant le tri.

— Dennis

2

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.

— Chaîne indépendante
source

Et maintenant, j'ai besoin de sommeil

— Chaîne indépendante

2

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.

— Adam
source

1

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!

— Dennis
source

1

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.

— Adam
source

1

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.

— Chaîne indépendante
source

0

𝔼𝕊𝕄𝕚𝕟, 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

— Mama Fun Roll
source

0

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

— Lynn
source

Par intérêt, pourquoi avez-vous dû définir ici votre propre type de liste? (Sont ==et <ne sont pas définis par défaut pour les listes?)

1

le type de données est récursif: je le définis Scomme une liste (encapsulée L) d' Ses. Haskell n'a pas de type intégré qui peut représenter des listes de listes de listes de…

— Lynn

0

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!

— bb94
source

Certaines choses: vous n'avez pas besoin de l'espace après les arguments du bloc de code, il est souvent plus court d'utiliser la $^syntaxe à la place, et je ne pense pas que l' []entrée fonctionne, car tout, [[]],[[[]]],[[[[]]]]etc., est évalué[]

— Jo King

0

Wolfram Language (Mathematica) , 20 octets

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

Essayez-le en ligne!

Fonction pure qui prend chaque ensemble en argument.

— Camarade SparklePony
source

Les deux ensembles sont-ils égaux

CJam, 11 octets

CJam, 13 octets

Gelée , 6 octets

Comment ça fonctionne

Brachylog , 8 octets

Explication

Pyth, 9 octets

Mathematica, 16 octets

JavaScript (ES6), 42 octets

Python 2, 49 octets

Prolog (SWI) , 37 octets

Prolog (SWI) , 60 octets

Prolog (SWI) , 57 octets

APL (NARS2000), 4 octets

Julia, 36 35 32 octets

SETL, 1 octet

Brachylog v2, 3 octets

𝔼𝕊𝕄𝕚𝕟, 7 caractères / 9 octets

Explication

Haskell, 77 octets

Perl 6 , 55 octets

Wolfram Language (Mathematica) , 20 octets