{}เป็นชุดที่ว่างเปล่า คุณสามารถใช้()หรือ[]ถ้าคุณเลือก

เราจะไม่กำหนด "ชุด" อย่างจริงจัง แต่ตั้งค่าทั้งหมดตามคุณสมบัติต่อไปนี้:

ชุดตามโครงสร้างทางคณิตศาสตร์ตามปกติ นี่คือบางจุดสำคัญ:

• ไม่มีการสั่งซื้อชุด
• ไม่มีชุดประกอบด้วยตัวเอง
• องค์ประกอบอยู่ในเซตหรือไม่นี่คือบูลีน ดังนั้นองค์ประกอบชุดจึงไม่สามารถมีหลายหลากได้ (เช่นองค์ประกอบไม่สามารถอยู่ในชุดได้หลายครั้ง)
• องค์ประกอบของชุดก็เป็นชุดและ{}เป็นองค์ประกอบดั้งเดิมเท่านั้น

งาน

เขียนโปรแกรม / ฟังก์ชั่นที่กำหนดว่าสองชุดเท่ากัน

อินพุต

ชุดที่ถูกต้องสองชุดผ่าน stdin หรืออาร์กิวเมนต์ของฟังก์ชัน รูปแบบการป้อนข้อมูลหลวมภายในเหตุผล

อินพุตที่ถูกต้องบางส่วนคือ:

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

อินพุตไม่ถูกต้อง:

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

เอาท์พุต

ค่าความจริงถ้าอินพุตเท่ากันเป็นเท็จ

กรณีทดสอบ

การส่งของคุณควรตอบอย่างถูกต้องสำหรับอินพุตที่ถูกต้องทั้งหมดไม่เพียง แต่สำหรับกรณีทดสอบ สิ่งเหล่านี้อาจได้รับการปรับปรุงในทุกจุด

Truthy:

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

Falsy:

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

เกณฑ์การให้คะแนน

รหัสกอล์ฟ

กฎเพิ่มเติม

มีการเพิ่มกฎเพิ่มเติมโดยห้ามแบนประเภทที่ทำซ้ำไม่ได้เรียงลำดับทั้งหมด พวกเขาธรรมดาเกินไปและทำให้ความท้าทายนี้เล็กน้อยเกินไป อย่าลังเลที่จะออกคำตอบที่ละเมิดสิ่งนี้ในสถานที่โปรดระบุสิ่งที่พวกเขาทำก่อนที่จะเปลี่ยนกฎ

CJam, 11 ไบต์

q']/"]$"*~=

ลองที่นี่

CJam, 13 ไบต์

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

ลองที่นี่

เยลลี่ 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.

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

Pyth, 9 ไบต์

LSyMbqyEy

รูปแบบอินพุตใช้งาน: ใช้แทน[]{}

ชุดทดสอบ

Mathematica ขนาด 16 ไบต์

Equal@@Sort//@#&

ฟังก์ชั่นที่ไม่มีชื่อซึ่งคาดว่ารายการที่มีทั้งสองชุดเช่น

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

เราใช้//@( MapAll) เพื่อจัดเรียงชุดในทุกระดับแล้วยืนยันที่ผลลัพธ์จะเท่ากัน

JavaScript (ES6), 42 ไบต์

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

รับข้อมูลการใช้[]s f([[],[[]]],[[[]],[]])เช่น ทำงานโดยแปลงอาร์เรย์เป็นสตริงแล้วเรียงลำดับจากภายในสู่ภายนอก 0และ1ถูกนำมาใช้เพราะพวกเขากำลังสั้นกว่า'['และ']'ดังนั้นสำหรับตัวอย่างg([[[]],[]])เป็นซึ่งหมายถึง001,00111[[],[[]]]

Python 2, 49 ไบต์

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

ตัวอย่างเช่นการเรียกใช้ฟังก์ชันที่ไม่ระบุชื่อg:

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

Prolog (SWI)ขนาด 37 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นรายการซ้อนกันเช่นมีเครื่องหมายวงเล็บเหลี่ยมแทนวงเล็บปีกกา แต่เดิมนี้เป็นX+Y:-sort(X,M),sort(Y,N),maplist(+,M,N).แต่ฉันลองแปล Brachylog v1 ของ Fatalize แล้วมันก็สั้นลง 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).

ลองออนไลน์!

*นี่คือการแปลง (nonempty ดังนั้น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.

ตั้งแต่การขัดแย้งทั้งสอง+กำลังจะผ่าน*ไปแล้ววางsortใน*บันทึก 7 ไบต์มากกว่าการใช้ในpermutation+

และสุดท้ายนี่คือเวอร์ชันที่จัดการรายการอินพุตที่อาจมีองค์ประกอบที่ซ้ำกันซึ่งเป็นแรงบันดาลใจให้ฉันเขียนวิธีแก้ไขปัญหาใน 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 เป็นเซตที่เท่ากัน

APL (NARS2000), 4 ไบต์

≡⍦

⍦เป็นโอเปอเรเตอร์มัลติเซ็ตซึ่งแก้ไขฟังก์ชั่นเพื่อจัดการกับข้อโต้แย้งของพวกมันในฐานะชุดแทนที่จะ
≡เป็นลิสต์คือฟังก์ชั่นความเท่ากันซึ่งจะส่งกลับบูลีนที่ระบุว่าข้อโต้แย้งนั้นมีค่าเทียบเท่า

เกี่ยวกับกฎเพิ่มเติม: โปรดทราบว่าคำตอบนี้ไม่ได้ใช้ประเภทข้อมูลชุดที่ไม่เรียงลำดับ แต่เป็นรายการปกติ (ซึ่งอาจมีองค์ประกอบที่เหมือนกันหลายรายการ) มันแค่ปฏิบัติต่อพวกเขาเป็นชุด

จำนวนไบต์คือ 4 เนื่องจาก NARS2000 ใช้ UCS-2 โดยเฉพาะ

Julia, 36 35 32 ไบต์

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

การป้อนข้อมูลเป็นอาร์เรย์ที่ซ้อนกันอย่างใดอย่างหนึ่งอย่างใดอย่างหนึ่ง (เลิก) ไวยากรณ์หรือ{}Any[]

ลองออนไลน์!

SETL ขนาด 1 ไบต์

=

ใช้ชุดเป็นอาร์กิวเมนต์ซ้ายและขวา

โปรดทราบว่าสิ่งนี้ไม่เป็นไปตามกฎที่เพิ่มซึ่งห้ามประเภทข้อมูลชุดที่ไม่เรียงลำดับ

Brachylog v2, 3 ไบต์

p↰ᵐ

ลองออนไลน์!

รับหนึ่งชุดผ่านตัวแปรอินพุตและอีกชุดผ่านตัวแปรเอาต์พุต ประสบความสำเร็จหากเซตเท่ากันและล้มเหลวหากไม่สำเร็จ

เช่นเดียวกับคำตอบ Prolog หลักของฉันการแปลคำตอบ Brachylog v1 ของ Fatalize (ซึ่งฉันคิดว่าน่าจะลงไป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 ตัวอักษร / 9 ไบต์

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

คำอธิบาย

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

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

Perl 6 , 55 ไบต์

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

[]จะเข้ากับ

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 20 ไบต์

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

ลองออนไลน์!

ฟังก์ชั่นบริสุทธิ์ที่ใช้แต่ละชุดเป็นอาร์กิวเมนต์