{}là tập hợp trống. Bạn có thể sử dụng ()hoặc []nếu bạn chọn.

Chúng tôi sẽ không định nghĩa chặt chẽ "bộ", nhưng bộ tất cả đều thỏa mãn các thuộc tính sau:

Bộ theo cấu trúc toán học thông thường. Dưới đây là một số điểm quan trọng:

• Bộ không được đặt hàng.
• Không có bộ chứa chính nó.
• Các phần tử có trong một tập hợp hoặc không, đây là boolean. Do đó, các phần tử tập hợp không thể có bội số (tức là một phần tử không thể nằm trong một tập hợp nhiều lần.)
• Các phần tử của một tập hợp cũng là các tập hợp và {}là phần tử nguyên thủy duy nhất.

Bài tập

Viết chương trình / hàm xác định xem hai tập có bằng nhau không.

Đầu vào

Hai bộ hợp lệ thông qua stdin hoặc đối số hàm. Các định dạng đầu vào là lỏng lẻo trong lý do.

Một số đầu vào hợp lệ là:

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

Đầu vào không hợp lệ:

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

Đầu ra

Một giá trị trung thực nếu các đầu vào bằng nhau, giả mạo khác.

Các trường hợp thử nghiệm

Việc gửi của bạn phải trả lời chính xác cho tất cả các đầu vào hợp lệ, không chỉ cho các trường hợp thử nghiệm. Đây có thể được cập nhật tại bất kỳ điểm nào.

Sự thật:

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

Giả mạo:

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

Chấm điểm

mã golf

Quy tắc bổ sung

Một quy tắc bổ sung đã được thêm vào cấm hoàn toàn các loại lặp không có thứ tự. Họ quá phổ biến và tầm thường hóa thử thách này quá nhiều. Vui lòng để lại câu trả lời vi phạm điều này, vui lòng chỉ đưa ra một dấu hiệu cho thấy chúng được thực hiện trước khi thay đổi quy tắc.

CJam, 11 byte

q']/"]$"*~=

Hãy thử nó ở đây.

CJam, 13 byte

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

Hãy thử nó ở đây.

Thạch , 6 byte

߀Ṣ
ÇE

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

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

{p:1a.}.

Điều này mong đợi dấu ngoặc trong Đầu vào và Đầu ra.

Ví dụ:

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

Giải trình

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

Bình thường, 9 byte

LSyMbqyEy

Định dạng đầu vào: sử dụng []thay vì {}.

Bộ kiểm tra

Toán học, 16 byte

Equal@@Sort//@#&

Một hàm không tên dự kiến ​​một danh sách chứa cả hai bộ, ví dụ

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

Chúng tôi sử dụng //@( MapAll) để sắp xếp các tập hợp ở mọi cấp độ và sau đó khẳng định kết quả là bằng nhau.

JavaScript (ES6), 42 byte

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

Chấp nhận đầu vào bằng []s eg f([[],[[]]],[[[]],[]]). Hoạt động bằng cách chuyển đổi các mảng thành chuỗi và sau đó sắp xếp chúng từ trong ra ngoài. 0và 1được sử dụng vì chúng ngắn hơn '['và ']', ví dụ như g([[[]],[]])là 001,00111đại diện [[],[[]]].

Python 2, 49 byte

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

Ví dụ: gọi hàm ẩn danh g:

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

Prolog (SWI) , 37 byte

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng danh sách lồng nhau, nghĩa là với dấu ngoặc vuông thay vì dấu ngoặc nhọn. Ban đầu, đây là X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., nhưng sau đó tôi đã thử dịch câu trả lời Brachylog v1 của Fatalize và nó ngắn hơn 3 byte.

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)

Nó thực sự có thể xử lý các dấu ngoặc nhọn thay vào đó, để có thêm 23 byte:

Prolog (SWI) , 60 byte

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

Hãy thử trực tuyến!

*ở đây chuyển đổi một X=Y;thuật ngữ niềng răng (không trống, do đó ) ở bên phải của nó thành một danh sách các phần tử của thuật ngữ sau đó sắp xếp nó sang bên trái của nó.

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

Kể từ khi cả hai đối số +đang trải qua *rồi, đặt một sorttrong *tiết kiệm 7 byte qua sử dụng permutationtrong+ .

Và cuối cùng, đây là phiên bản xử lý các danh sách đầu vào có thể có các yếu tố trùng lặp, đó là điều đã truyền cảm hứng cho tôi viết một giải pháp trong Prolog để bắt đầu:

Prolog (SWI) , 57 byte

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

Hãy thử trực tuyến!

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.

Về cơ bản, X/Ytuyên bố rằng X là tập con của Y, bằng cách tuyên bố rằng với mọi phần tử của X, có một phần tử bằng nhau của Y, do đó X/Y,Y/Xtuyên bố rằng X và Y là các tập bằng nhau.

APL (NARS2000), 4 byte

≡⍦

⍦ là toán tử multiset, nó sửa đổi các hàm để coi các đối số của chúng là tập hợp thay vì danh sách
≡ là hàm tương đương, trả về một Boolean cho biết nếu các đối số hoàn toàn tương đương về giá trị và hình dạng

Về quy tắc bổ sung: Lưu ý rằng câu trả lời này không sử dụng bất kỳ kiểu dữ liệu tập hợp không có thứ tự nào, mà chỉ là các danh sách bình thường (có thể chứa nhiều phần tử giống hệt nhau). Nó chỉ xử lý chúng là bộ.

Số byte là 4 vì NARS2000 chỉ sử dụng UCS-2.

Julia, 36 35 32 byte

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

Đầu vào là một mảng lồng nhau hoặc là {}cú pháp (không dùng nữa) hoặc Any[].

Hãy thử trực tuyến!

SETL, 1 byte

=

Đưa ra các đối số trái và phải.

Lưu ý rằng điều này KHÔNG tuân thủ quy tắc được thêm vào, cấm các kiểu dữ liệu được đặt không có thứ tự.

Brachylog v2, 3 byte

p↰ᵐ

Hãy thử trực tuyến!

Đưa một bộ qua biến đầu vào và bộ kia qua biến đầu ra. Thành công nếu các bộ bằng nhau và thất bại nếu chúng không.

Giống như câu trả lời Prolog chính của tôi, một bản dịch của câu trả lời Brachylog v1 của Fatalize (mà tôi nghĩ có thể bị đánh golf xuống 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 ký tự / 9 byte

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

Giải trình

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

Haskell, 77 byte

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 byte

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

Đưa đầu vào với [].

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 20 byte

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

Hãy thử trực tuyến!

Hàm thuần túy lấy mỗi bộ làm đối số.