{}boş kümedir. Kullanabilir ()veya []isterseniz.

Biz "set" i titizlikle tanımlamayacağız, fakat hepsi aşağıdaki özellikleri karşılayacak şekilde ayarlar:

Kümeler olağan matematiksel yapıyı takip eder. İşte bazı önemli noktalar:

• Setler sipariş edilmez.
• Hiçbir küme kendisini içermez.
• Elemanlar ya bir kümede ya da değil, bu boolean. Bu nedenle, ayar öğelerinin çokluğu olamaz (yani, bir öğe kümede birden çok kez olamaz.)
• Bir kümenin elemanları da kümelerdir ve {}tek ilkel öğedir.

Görev

İki kümenin eşit olup olmadığını belirleyen bir program / işlev yazın.

Giriş

Stdin veya işlev argümanı ile iki geçerli küme. Giriş biçimi mantıklı değil.

Bazı geçerli girdiler:

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

Geçersiz girişler:

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

Çıktı

Girdiler eşitse doğruluk değeri, aksi halde tahrif.

Test senaryoları

Gönderiniz sadece test senaryoları için değil, tüm geçerli girişler için doğru cevap vermelidir. Bunlar herhangi bir zamanda güncellenebilir.

Doğru:

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

Falsy:

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

puanlama

kod golf

Ek Kurallar

Sırasız yinelenebilir türleri tamamen yasaklayan ek bir kural eklenmiştir. Çok yaygınlar ve bu meydan okumayı çok fazla önemsizleştiriyorlar. Bunu ihlal eden cevapları bırakmaktan çekinmeyin, lütfen sadece kural değişikliğinden önce yapıldığına dair bir işaret verin.

CJam, 11 bayt

q']/"]$"*~=

Burada deneyin.

CJam, 13 bayt

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

Burada deneyin.

Jöle , 6 bayt

߀Ṣ
ÇE

Çevrimiçi deneyin! veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

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

{p:1a.}.

Bu, Giriş ve Çıkış'ta parantez bekler.

Örneğin:

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

açıklama

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

LSyMbqyEy

Girdi biçimi: []yerine kullanın {}.

Test odası

Mathematica, 16 bayt

Equal@@Sort//@#&

Her iki seti içeren bir listeyi bekleyen isimsiz bir işlev, ör.

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

Kümeleri her düzeyde sıralamak için //@( MapAll) kullanırız ve sonuçlarda eşit olduğunu iddia ederiz .

JavaScript (ES6), 42 bayt

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

[]S kullanarak girişi kabul eder örn f([[],[[]]],[[[]],[]]). Dizileri dizelere dönüştürüp içten dışa doğru sıralayarak çalışır. 0ve 1kullanılırlar çünkü bunlar daha kısadır '['ve ']'örneğin g([[[]],[]]), 001,00111hangisini temsil eder [[],[[]]].

Python 2, 49 bayt

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

Örneğin, anonim işlevi çağırmak g:

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

Prolog (SWI) , 37 bayt

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

Çevrimiçi deneyin!

Girişi iç içe listeler olarak alır, diğer bir deyişle parantez yerine köşeli parantez ile. Aslında, bu oldu X+Y:-sort(X,M),sort(Y,N),maplist(+,M,N)., ama sonra Fatalize'ın Brachylog v1 cevabını çevirmeyi denedim ve 3 bayt daha kısa çıktı.

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 bayt için aslında kıvırcık parantezleri işleyebilir:

Prolog (SWI) , 60 bayt

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

Çevrimiçi deneyin!

*burada X=Y;sağ tarafındaki (boş olmayan, dolayısıyla ) bir ayraç terimini, terimin öğelerinin listesine dönüştürür ve sonra onu sol tarafına sıralar.

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

Her iki argüman için yana +geçiyor *zaten, bir koyarak sortin *kullanılmasına göre 7 bayt kaydeder permutationiçinde +.

Ve son olarak, giriş listelerinin muhtemelen yinelenen öğelere sahip olan bir sürümü var, bu da Prolog'da başlamak için bir çözüm yazmam için bana ilham verdi:

Prolog (SWI) , 57 bayt

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

Çevrimiçi deneyin!

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.

Esasen, X/YX'in Y'nin bir alt kümesi olduğunu beyan eder, X'in her elemanı için Y'nin eşit bir elemanı X/Y,Y/Xolduğunu söyleyerek X ve Y'nin eşit kümeler olduğunu beyan eder.

APL (NARS2000), 4 bayt

≡⍦

⍦argümanlarını listeler yerine küme olarak ele almak için işlevleri değiştiren çoklu küme işleci,
≡bağımsız değişkenlerin değer ve şekil bakımından tamamen eşdeğer olup olmadığını gösteren bir Boole döndüren denklik işlevidir.

Ek kuralla ilgili olarak: Bu cevabın sıralanmamış küme veri türü değil, yalnızca normal listeler (birden çok özdeş öğe içerebilir) kullandığını unutmayın. Sadece set olarak davranır .

Bayt sayısı 4'tür çünkü NARS2000 yalnızca UCS-2 kullanır.

Julia, 36 35 32 bayt

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

Girdi, (kullanımdan kaldırıldı) {}sözdizimi veya Any[].

Çevrimiçi deneyin!

SETL, 1 bayt

=

Kümeleri sol ve sağ argümanlar olarak alır.

Bunun, ayarlanmamış küme veri türlerini yasaklayan eklenen kurala uymadığını unutmayın.

Brachylog v2, 3 bayt

p↰ᵐ

Çevrimiçi deneyin!

Bir seti girdi değişkeni, diğerini de çıktı değişkeni üzerinden alır. Kümeler eşitse başarılı olur ve kümeler başarısız olursa başarısız olur.

Benim ana Prolog cevabım gibi, Fatalize'ın Brachylog v1 cevabının bir çevirisi (ki bence golf oynayabilir p:0ami?).

       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 karakter / 9 bayt

ѨƾꞨî,Ꞩí

Try it here (ES6 browsers only).

açıklama

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

Haskell, 77 bayt

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 bayt

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

İle girdi alır [].

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 20 bayt

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

Çevrimiçi deneyin!

Her seti bağımsız değişken olarak alan saf işlev.