两组相等吗

9

{}是空集。您可以使用，()也[]可以选择使用。

我们不会严格定义“集合”，但是集合都满足以下属性：

集合遵循通常的数学结构。以下是一些要点：

  • 集不排序。
  • 没有集合包含自身。
  • 元素是否在集合中，这是布尔值。因此，集合元素不能具有多重性（即，一个元素不能多次出现在集合中。）
  • 集合的元素也是集合，并且{}是唯一的原始元素。

任务

编写确定两个集合是否相等的程序/函数。

输入项

通过stdin或function参数的两个有效集合。输入格式不合理。

一些有效的输入是：

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

输入无效：

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

输出量

如果输入相等，则为真实值，否则为假。

测试用例

您的提交应正确回答所有有效输入，而不仅仅是测试用例。这些可以随时更新。

真相：

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

虚假：

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

计分

代码高尔夫球

附加规则

添加了一条附加规则，完全禁止无序可迭代类型。它们太普遍了，并且使挑战变得微不足道。请随意将违反此规定的答案留在原处，请仅注明是在更改规则之前做出的。

code-golf  decision-problem  balanced-string 
— 利亚姆
source
具有可嵌套集合类型的语言可以检查是否相等吗？
— xnor
@xnor内置插件应该是公平的游戏，是的
— Liam
1
@Dennis很好，即使这是一个“平衡字符串”挑战，我也从未真正将其视为解析挑战。但是，现在我考虑了一下，通过假设所有输入均有效，我已经使其成为解析难题。所以我认为你是对的。足够多的语言可能会想到一个无序列表，这将使这一问题变得微不足道。
— 利亚姆
1
无论您做出什么决定，我都会好起来的。就我个人而言，尽管我认为使用集在某种程度上仍可以保持创造性，而又不影响挑战（例如我的Julia答案，它将递归地将嵌套数组转换为嵌套集），但允许嵌套集作为输入会使整个事情变得太简单了（==在Julia，2个字节；frozenset.__eq__在Python中，为16个字节；等等。
— 丹尼斯，2016年
8
See the comments for an explanation. 请不要这样做。评论多变，很容易消失，因此重要的sutff出现在帖子的正文中
— 猫

Answers:

4

果冻，6 个字节

߀Ṣ
ÇE

在线尝试！或验证所有测试用例。

怎么运行的

Ç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.
— 丹尼斯
source
3

Brachylog，8个字节

{p:1a.}.

这需要输入和输出中的括号。

例如： 

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

说明

{     }.   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
— 致命
source
2

Mathematica，16个字节

Equal@@Sort//@#&

一个未命名的函数，期望一个包含两个集合的列表，例如

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

我们使用//@（MapAll）对每个级别的集合进行排序，然后断言结果是否相等。

— 马丁·恩德
source
2

JavaScript（ES6），42个字节

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

使用接受输入，[]例如f([[],[[]]],[[[]],[]])。通过将数组转换为字符串，然后从内到外对它们进行排序来工作。0和1使用，因为它们比更短的'['和']'，因此，例如g([[[]],[]])是001,00111其表示[[],[[]]]。

— 尼尔
source
你不使用递归，所以你可以把它化名
— 巴林特
为什么在0+那里？
— 巴林特
@Bálint因为没有0+，+1我得到的只是逗号。
— 尼尔
@Bálint我不知道为什么我忘记删除f=，我没有将其包括在字节数中，而且我也懒得为此编辑帖子。
— 尼尔
2

Python 2，49字节

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

例如，调用匿名函数g：

>>> g( [[],[[]]] , [[[]],[]] )
True
— 林恩
source
g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]])返回False，但集合相等。应该在排序之前通过映射解决此问题。
— 丹尼斯
2

Prolog（SWI），37个字节

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

在线尝试！

将输入作为嵌套列表，即使用方括号而不是大括号。最初是X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N).，但后来我尝试翻译Fatalize的Brachylog v1答案，结果缩短了3个字节。

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)

实际上，它可以代替23个字节来使用花括号：

Prolog（SWI），60字节

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

在线尝试！

*在这里，将X=Y;右方的一个（非空的，因此为）大括号术语转换为该术语的元素列表，然后将其排序至其左侧。

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

由于to的两个参数+都已通过*，因此放置sortin *比使用permutationin 节省7个字节+。

最后，这是一个处理可能包含重复元素的输入列表的版本，这就是促使我在Prolog中编写解决方案的开始：

Prolog（SWI），57字节

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

在线尝试！

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/Y通过声明X的每个元素都有一个等价的Y来声明X是Y的子集，因此X/Y,Y/X声明X和Y是相等的集合。

— 不相关的字符串
source
现在我需要睡觉
— 不相关的字符串
2

APL（NARS2000），4个字节

≡⍦

⍦是多集运算符，它修改函数以将其自变量视为集合而不是列表，
≡是等价函数，它返回一个布尔值，指示参数在值和形状上是否完全相等

关于附加规则：请注意，此答案不使用任何无序集合数据类型，而仅使用普通列表（其中可能包含多个相同的元素）。它只是将它们视为集合。

字节数为4，因为NARS2000仅使用UCS-2。

— 亚当
source
1

朱莉娅36 35 32字节

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

输入是（不建议使用的）{}语法或的嵌套数组Any[]。

在线尝试！

— 丹尼斯
source
1

SETL，1个字节

=

将集合作为左右参数。

请注意，这不遵守添加的规则，该规则禁止无序设置的数据类型。

— 亚当
source
1

Brachylog v2，3个字节

p↰ᵐ

在线尝试！

通过输入变量获取一组，通过输出变量获取另一组。如果集合相等，则成功；否则，则失败。

就像我的主要Prolog答案一样，是Fatalize的Brachylog v1答案的翻译（我认为可以打成低调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.
— 不相关的字符串
source
0

Haskell，77个字节

import Data.List
data S=L[S]deriving(Eq,Ord)
f(L x)=L$sort$f<$>x
a!b=f a==f b
— 林恩
source
出于兴趣，您为什么需要在此处定义自己的列表类型？（现==并<没有被默认列表定义？）
1
数据类型是递归的：我定义S为es 的（包装L）列表S。Haskell没有内置类型可以表示…的列表的列表
— Lynn
0

Perl 6、55个字节

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

使用输入[]。

在线尝试！

— bb94
source
有些事情：您不需要在代码块的参数后面留空格，而使用$^语法通常会更短，而且我认为[]输入不起作用，因为所有其他[[]],[[[]]],[[[[]]]]计算结果都为[]
— Jo King
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.