क्या दो सेट बराबर हैं

Question

{}खाली सेट है। यदि आप चुनते हैं तो आप उपयोग ()या []कर सकते हैं।

हम "सेट" को सख्ती से परिभाषित नहीं करने जा रहे हैं, लेकिन सभी सेट निम्नलिखित गुणों को पूरा करते हैं:

सेट सामान्य गणितीय संरचना का पालन करते हैं। यहाँ कुछ महत्वपूर्ण बिंदु हैं:

• सेट के आदेश नहीं हैं।
• कोई भी सेट अपने आप में नहीं होता।
• तत्व या तो एक सेट में हैं या नहीं, यह बूलियन है। इसलिए सेट तत्वों की बहुलता नहीं हो सकती है (अर्थात एक तत्व कई बार सेट में नहीं हो सकता है।)
• एक सेट के तत्व भी सेट हैं और {}एकमात्र आदिम तत्व है।

कार्य

एक प्रोग्राम / फ़ंक्शन लिखें जो यह निर्धारित करता है कि क्या दो सेट समान हैं।

इनपुट

स्टड या फ़ंक्शन तर्क के माध्यम से दो मान्य सेट। इनपुट प्रारूप कारण के भीतर ढीला है।

कुछ मान्य इनपुट निम्न हैं:

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

अमान्य इनपुट:

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

उत्पादन

एक सत्य मान यदि इनपुट समान हैं, तो गलत है।

परीक्षण के मामलों

आपके प्रस्तुतिकरण को सभी मान्य इनपुट के लिए सही ढंग से उत्तर देना चाहिए, न कि केवल परीक्षण मामलों के लिए। इन्हें किसी भी बिंदु पर अद्यतन किया जा सकता है।

Truthy:

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

Falsy:

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

स्कोरिंग

कोड गोल्फ

अतिरिक्त नियम

एक अतिरिक्त नियम पूरी तरह से अनियंत्रित चलने योग्य प्रकारों पर प्रतिबंध लगाते हुए जोड़ा गया है। वे बहुत आम हैं और इस चुनौती का बहुत अधिक सामना करते हैं। इस जगह का उल्लंघन करने वाले उत्तर को छोड़ने के लिए स्वतंत्र महसूस करें, कृपया केवल एक संकेत दें कि वे नियम परिवर्तन से पहले किए गए थे।

Comments

क्या एक नेस्टेबल सेट प्रकार वाली भाषा सिर्फ समानता की जांच कर सकती है?

— 1

@xnor बिल्ट-इन फेयर गेम होना चाहिए, हां

— लियाम

@ अच्छी तरह से, भले ही यह एक "संतुलित-स्ट्रिंग" चुनौती है, मैंने कभी भी इसे एक चुनौतीपूर्ण चुनौती के रूप में नहीं सोचा था। लेकिन, अब जब कि मैं इसके बारे में सोचता हूं, तो यह मानकर कि सभी इनपुट वैध हैं, मैंने इसे एक चुनौती बना दिया है। इसलिए मुझे लगता है कि आप सही हैं। पर्याप्त भाषाओं को शायद एक अन-ऑर्डर की गई सूची का विचार है जो इस बात को स्पष्ट करेगा।

— लियाम

आप जो भी निर्णय लेंगे मैं ठीक हूँ। व्यक्तिगत रूप से, जब मुझे लगता है कि सेट का उपयोग करना किसी भी तरह चुनौती को स्वीकार किए बिना रचनात्मक हो सकता है (जैसे मेरे जूलिया जवाब, जो एक नेस्टेड सरणी को एक नेस्टेड सेट में बदल देता है), नेस्टेड सेट को इनपुट के रूप में अनुमति देता है, पूरी बात को थोड़ा सरल बनाता है ( ==में जूलिया, 2 बाइट्स; frozenset.__eq__अजगर में, 16 बाइट्स; आदि)।

— डेनिस

See the comments for an explanation. कृपया ऐसा न करें। टिप्पणियाँ अस्थिर होती हैं और बहुत आसानी से चली जाती हैं, इसलिए महत्वपूर्ण शरीर पोस्ट शरीर में

— बिल्ली

Answer 1

सीजेएम, 11 बाइट्स

q']/"]$"*~=

इसे यहाँ आज़माएँ।

सीजेएम, 13 बाइट्स

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

इसे यहाँ आज़माएँ।

Answer 2

जेली , 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.

Answer 3

ब्रेकीलॉग , 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

Answer 4

अजगर, 9 बाइट्स

LSyMbqyEy

इनपुट प्रारूप: के []बजाय का उपयोग करें {}।

परीक्षण सूट

Answer 5

गणितज्ञ, 16 बाइट्स

Equal@@Sort//@#&

एक अनाम फ़ंक्शन जो किसी सूची की अपेक्षा करता है जिसमें दोनों सेट होते हैं, जैसे

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

हम हर स्तर पर सेटों को क्रमबद्ध करने के लिए //@( MapAll) का उपयोग करते हैं और फिर परिणामों पर जोर देते हैं।

Answer 6

जावास्क्रिप्ट (ईएस 6), 42 बाइट्स

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

[]एस का उपयोग करके इनपुट स्वीकार करता है f([[],[[]]],[[[]],[]])। सरणियों को तारों में परिवर्तित करके और फिर उन्हें अंदर से बाहर छाँटने का काम करता है। 0और 1उपयोग किया जाता है क्योंकि वे इससे छोटे हैं '['और ']'इसलिए, उदाहरण के g([[[]],[]])लिए 001,00111जो प्रतिनिधित्व करता है [[],[[]]]।

Comments

तुम्हें पता है, प्रत्यावर्तन का उपयोग नहीं करते, तो आप इसे गुमनाम आदमी कर सकते हैं

— Bálint

ऐसा क्यों है 0+?

— बैलिंट

@ बैलिंट क्योंकि सभी के बिना 0+और +1मुझे मिल जाएगा अल्पविराम।

— नील

@ मुझे पता नहीं क्यों मैं हटाना भूल गया f=, मैंने इसे बाइट की गिनती में शामिल नहीं किया और मैं इसके लिए पोस्ट को संपादित करने के लिए बहुत आलसी हूं।

— नील

Answer 7

पायथन 2, 49 बाइट्स

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

उदाहरण के लिए, अनाम फ़ंक्शन को कॉल करना g:

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

Comments

g([[],[[],[]],[[],[[]]],[[]],[[[]]]], [[[],[]],[[[]],[]],[[]],[[[]]],[]])रिटर्न False, लेकिन सेट बराबर हैं। छँटाई से पहले मैपिंग करके इसे ठीक किया जाना चाहिए।

— डेनिस

Answer 8

प्रोलोग (एसडब्ल्यूआई) , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नेस्टेड सूचियों के रूप में इनपुट लेता है, अर्थात ब्रेसिज़ के बजाय वर्ग कोष्ठक के साथ। मूल रूप से, यह था X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., लेकिन फिर मैंने फैटलिज़ के ब्रेकीलॉग 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 बाइट्स के बजाय घुंघराले ब्रेसिज़ को संभाल सकता है:

प्रोलोग (एसडब्ल्यूआई) , 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.

चूंकि दोनों दलीलें पहले +से *ही चल रही हैं , ऐसे sortमें *7 बाइट्स को बचाने के लिए इनका इस्तेमाल करने से बचा permutationजाता है +।

और अंत में, यहां एक संस्करण है जो इनपुट सूचियों को संभवतः डुप्लिकेट तत्वों को संभालता है, जो कि मुझे शुरू करने के लिए प्रोलॉग में समाधान लिखने के लिए प्रेरित करता है:

प्रोलॉग (एसडब्ल्यूआई) , 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 समान सेट हैं।

Comments

और अब मुझे नींद की जरूरत है

— असंबंधित स्ट्रिंग

Answer 9

एपीएल (NARS2000), 4 बाइट्स

≡⍦

⍦मल्टीसेट ऑपरेटर है, जो अपने तर्कों को उपचार के लिए संशोधित करता है क्योंकि सूचियों के बजाय सेट
≡समतुल्य फ़ंक्शन है, जो एक बूलियन को संकेत देता है कि क्या तर्क पूरी तरह से मूल्य और आकार में समान हैं।

अतिरिक्त नियम के बारे में: ध्यान दें कि यह उत्तर किसी भी अव्यवस्थित सेट डेटाटाइप का उपयोग नहीं करता है, लेकिन सिर्फ सामान्य सूचियों (जिसमें कई समान तत्व हो सकते हैं)। यह उन्हें सेट के रूप में मानता है।

बाइट की गिनती 4 है क्योंकि NARS2000 यूसीएस -2 का विशेष रूप से उपयोग करता है।

Answer 10

जूलिया, 36 35 32 बाइट्स

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

इनपुट एक नेस्टेड ऐरे है या तो (पदावनत) {}सिंटैक्स या Any[]।

इसे ऑनलाइन आज़माएं!

Answer 11

एसईटीएल, 1 बाइट

=

बाएँ और दाएँ तर्क के रूप में सेट करता है।

ध्यान दें कि यह जोड़ा गया नियम का पालन नहीं करता है जो अनियंत्रित सेट डेटाैटेस को प्रतिबंधित करता है।

Answer 12

Brachylog v2, 3 बाइट्स

p↰ᵐ

इसे ऑनलाइन आज़माएं!

इनपुट चर के माध्यम से एक सेट लेता है और दूसरा आउटपुट चर के माध्यम से सेट करता है। यदि सेट बराबर हैं और विफल हो जाते हैं तो सफल हो जाते हैं।

मेरे मुख्य प्रोलॉग उत्तर की तरह, फैटलाइज़ के ब्रेकीलॉग 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.

Answer 13

S, 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

Answer 14

हास्केल, 77 बाइट्स

import Data.List
data S=L[S]deriving(Eq,Ord)
f(L x)=L$sort$f<$>x
a!b=f a==f b

Comments

रुचि से बाहर, आपको अपनी सूची प्रकार यहाँ परिभाषित करने की आवश्यकता क्यों है? (कर रहे हैं ==और <नहीं डिफ़ॉल्ट रूप से सूचियों के लिए परिभाषित किया गया?)

डेटाटैस पुनरावर्ती है: मैं तों की Sलिपटे (लिपटे-इन L) सूची के रूप में परिभाषित करता हूं S। हास्केल के पास कोई अंतर्निहित प्रकार नहीं है जो सूचियों की सूचियों का प्रतिनिधित्व कर सकता है ...

— लिन

Answer 15

पर्ल 6 , 55 बाइट्स

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

के साथ इनपुट लेता है []।

इसे ऑनलाइन आज़माएं!

Comments

कुछ चीजें: आपको कोड ब्लॉक के तर्कों के बाद स्थान की आवश्यकता नहीं है, यह अक्सर $^इसके बजाय सिंटैक्स का उपयोग करने के लिए कम होता है , और मुझे नहीं लगता कि []इनपुट काम करता है, क्योंकि [[]],[[[]]],[[[[]]]]आदि सभी का मूल्यांकन करते हैं[]

— जो किंग

Answer 16

वोल्फ्राम भाषा (गणितज्ञ) , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

शुद्ध फ़ंक्शन जो प्रत्येक सेट को एक तर्क के रूप में लेता है।