Meydan okuma

TSonlu bir kümenin alt kümeleri göz önüne alındığında , bir topolojiS={1,2,3,...,n} olup olmadığını belirleyin .T

açıklama

Powerset P(S) bazı setin Sher alt kümelerinin kümesidir S. Bazı örnekler:

S = {}, P(S) = {{}}
S = {1}, P(S) = {{}, {1}}
S = {1,2}, P(S) = {{}, {1}, {2}, {1,2}}
S = {1,2,3}, P(S) = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

Setteki bir topolojiT , aşağıdaki özelliklere sahip Sbir altkümedir P(S):

• {}içeride Tve SiçerideT
• Eğer Ave Biçindedir To zaman onların kavşak olduğunuA ∩ B
• Eğer Ave Biçindedir To zaman onların birleşmedir A ∪ B*

_{^{* Bu tanım tam olarak doğru değildir, ancak bu zorluğun amaçları için yeterli olan sonlu kümeler için geçerlidir. Gerçek aksiyom, sonsuz sendikalara da izin verirdi, ancak bu sonlu durumda önemsizdir.}}

ayrıntılar

• Bunu S = {1,2,...,n}(veya alternatif olarak S = {0,1,...,n}) nkümelerinde görünen en büyük tamsayının nerede olduğunu varsayabilirsiniz T.
• Giriş formatı esnektir: Bir dizgiyi, liste listesini veya liste grubunu veya dil sunucunuzun kullanabileceği benzer herhangi bir biçimi kullanabilirsiniz. Daha S = {0,1,...,n}uygunsa setleri de kullanabilirsiniz .
• Çıktı doğru veya yanlış olmalı.
• Ek bir giriş olarak kabul etmenize n(veya alternatif olarak n+1veya n-1) izin verilir .
• Sıralı listelerle çalışıyorsanız, küme içindeki sayıların sıralandığını varsayabilirsiniz. Listenin belirli bir sıraya sahip olduğunu da varsayabilirsiniz (örneğin, sözlük bilgisi.
• Kümeleri temsil ederken, liste gösterimlerinin hiçbir iki girişinin eşit olmadığını varsayabilirsiniz.

Örnekler

topoloji

{{}}  over {}
{{},{1}} over {1}
P(S) over S (see in the explanation)
{{},{1},{1,2}} over {1,2}
{{},{1},{2,3},{1,2,3}} over {1,2,3}
{{1}, {1,2,3}, {1,4,5,6}, {1,2,3,4,5,6}, {}, {2,3}, {4,5,6}, {2,3,4,5,6}}
{{}, {1}, {2,3}, {2}, {4,5,6}, {5,6}, {5}, {2,5,6}, {2,5}, {1,5}, {1,2,3,4,5,6}, {1,2,3}, {1,2}, {1,4,5,6}, {1,5,6}, {1,2,5,6}, {2,3,4,5,6}, {2,3,5,6}, {2,3,5}, {1,2,3,5}, {2,4,5,6}, {1,2,5}, {1,2,3,5,6}, {1,2,4,5,6}}
{{}, {1}, {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5}, {1,2,3,4,5,6}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8,9}}
{{}, {1}, {1,2,3}, {1,2,3,4,5}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8,9}}

olmayan topolojileri

{{1}} because {} is not contained
{{},{2}} because {1,2} is not contained
{{},{1,2},{2,3}} because the union {1,2,3} is not contained
{{},{1},{1,2},{2,3},{1,2,3}} because the intersection of {1,2} and {2,3} is not contained
{{},{1},{2},{3},{1,2},{2,3},{1,2,3}} because the union of {1} and {3} is not contained
{{}, {1}, {2,3}, {2}, {4,5,6}, {5,6}, {5}, {2,5,6}, {2,5}, {1,5}, {1,2,3,4,5,6}, {1,2,3}, {1,2}, {1,4,5,6}, {1,5,6}, {1,2,5,6}, {2,3,4,5,6}, {2,3,5,6}, {2,3,5}, {2,4,5,6}, {1,2,5}, {1,2,3,5,6}, {1,2,4,5,6}} because {1,2,3,5} is missing
{{}, {1}, {2}, {1,2,3}, {1,2,3,4,5}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8,9}} because {1,2} is missing 

Python 2 , 117 99 97 91 bayt

n,x=input();sum(set.union(*x))!=n*-~n/2>q
[map(x.index,(i-i,i|j,i&j))for i in x for j in x]

Çevrimiçi deneyin!

Çıkış, çıkış koduyla yapılır

Haskell , 95 89 74 78 bayt

import Data.List
t#n=all(`elem`t)$sort<$>[1..n]:[]:([union,intersect]<*>t<*>t)

Çevrimiçi deneyin!

Açıklama:

                              ([union,intersect]<*>t<*>t) -- create all unions & intersections 
                    [1..n]:[]:                            -- add the empty list and the full list
             sort<$>                                --sort them all
                                -- (as 'union' does not necessarily produce sorted outputs)
all(`elem`t)$                   -- check whether they are all already contained

Mathematica, 87 73 66 63 bayt

Outer[{#⋂#2,#⋃#2}&,#,#,1]~Flatten~2⋃{{},Range@#2}==#⋃#&

Alır [T, n]girdi olarak.

açıklama

{#⋂#2,#⋃#2}&

Kavşak ve girdilerin birleşimini döndüren işlev

Outer[ ... ,#,#,1]

Bu fonksiyonu seviye 1'deki giriş listesine eşleyin.

... ~Flatten~2

Sonucu düzeltin ( Outerkısım bir demet iç içe geçmiş Lists ile döner ).

... ⋃{{},Range@#2}

Yassılaştırılmış liste ve arasındaki birliği alın {{}, S}. Bu, kopyaları kaldırır ve ekler {}ve Selde edilen listeye ekler .

... ==#⋃#

Yukarıdaki listenin girişin sıralanmış versiyonuna eşit olup olmadığını kontrol edin.

MATL , 38 bayt

!t~hXAs1>GXBXH2Z^!"@Z}Z|1MZ&hHm]vAGn~+

Giriş, her satırın ayarlandığı, her sütunun bir öğe olduğu ve her girişin üyeliği belirttiği ikili bir matristir. Örneğin, {{},{1},{1,2}}olarak ifade edilir [0 0;1 0;1 1]. Bu formata dönüştürmek için bağlantılı Octave programını kullanın.

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

açıklama

!        % Implicit input. Transpose
t~       % Push a negated copy
h        % Horizontally concatenate both matrices
XA       % All: true for columns containing only 1
s        % Sum
1>       % Does it exceed 1? If so, both the empty set and the total
         % set are in the input
G        % Push input again
XB       % Convert each row from binary to decimal. This gives a column
         % vector of numbers that encode each set's contents. Union and
         % intersection will be done as bitwise XOR and AND
XH       % Copy to clipboard H
2Z^!     % Cartesian square transposed: gives all pairs of numbers as
         % columns of a matrix
"        % For each column
  @      %   Push current column
  Z}     %   Split into the two numbers
  Z|     %   Bitwise XOR
  1M     %   Push the two numbers again
  Z&     %   Bitwise AND
  h      %   Concatenate the two results horizontally
  Hm     %   Are they members of the vector of encoded sets? This gives
         %   a row vector with the two results
]        % End
v        % Concatenate all stack contents into a vertical vector
A        % Does it only contain ones? This is the main result: true iff
         % input is a non-empty topology. The empty input gives false,
         % and so it needs to be special cased
G        % Push input again
n~       % Is it empty?
+        % Add thw two results. Implicit display

Python 2 , 92 71 122 bayt

• Ağır 19 baytlık bir azaltma için @ovs'a çok teşekkürler: &ve |ayar işlemleri için kısa yollar .
• 5 byte için @ notjagan @ teşekkürler
• 2 byte için @ovs sayesinde: set()olaraki-i

Girdi olarak kümelerin listesini alan ve True / false değerini döndüren Lambda. Boş bir set olup olmadığını ve her setin ( ive olarak yinelenen iki set j) birliği ve kesişiminin verilen setler listesinde olup olmadığını kontrol eder.

lambda x:x.sort()or all(k in x[-1]for k in range(1,max(x[-1])))and all(a in x for i in x for j in x for a in[i-j,i|j,i&j])

Çevrimiçi deneyin!

CJam (23 bayt)

{[,M2$2m*{_~&\~|$}/]^!}

Çevrimiçi test paketi . Bu anonim bir bloktur (fonksiyon). Sanırım S = {0,1,...,n}; blok, bir dizi sıralanmış diziyi ve n+1parametreler ve yapraklar olarak 0veya 1istifin üzerinde alır. Bu durumda {{}}kod ve test çerçevesi bunu varsaymaktadır n+1 = 0.

Pyth, 24 23 bayt

q@aasm,@Fd{Ssd*QQYJUEyJ

Test odası

Bu program, sıralı listelerin sıralı listesi olarak girdi alır. İç listeler artan düzende olmalı ve sipariş listesi uzunlukça sonra sözlüksel olarak sıralanmalıdır. Bunun izin verilen bir giriş formatı olduğunu onayladım. Sayılar 0'dan başlar ve N + 1 de giriş olarak alınır.

Nasıl çalıştığıyla ilgili olarak, P (S) 'de olmayan her şeyi filtrelendiriyoruz, sonra S'yi, []her bir çiftin kesişimi ve her bir çiftin birliğinin kesişimini ekledik, veri tekilleştirin ve sonucun girdiyle aynı olup olmadığını kontrol ettik.

Aksiyom, 358 bayt

t(a,s)==(aa:=sort(removeDuplicates(a));ss:=sort(removeDuplicates(s));a:=sort(a);s:=sort(s);a~=aa or s~=ss=>false;a:=map(sort, a);~member?([],a) or ~member?(s,a)=>false;for x in a repeat(for j in x repeat if ~member?(j,s) then return false;for y in a repeat if ~member?(sort(setIntersection(x,y)),a) or ~member?(sort(setUnion(x,y)),a) then return false);true)

ungolfed ve sonuçları:

-- all the List have to be sorted because in list [1,2]~=[2,1]
-- So here "set" means: "List without duplicate, sorted with sort() function"
-- Return true if 
-- 1) a,s are set for above definition
-- 2) a is in P(s) 
-- 3) s,[] are in a
-- 4) for all x and y in a => xUy is in a and x intersect y is in a
t1(a:List List INT, s:List INT):Boolean==
    aa:=sort(removeDuplicates(a));ss:=sort(removeDuplicates(s))
    a :=sort(a);                  s :=sort(s)
    a~=aa          or s~=ss        =>false   -- they are not sets but list with element duplicate
    a:=map(sort, a)                          -- subset of a has to be sorted too
    ~member?([],a) or ~member?(s,a)=>false
    for x in a repeat
       for j in x repeat if ~member?(j,s) then return false 
       for y in a repeat if ~member?(sort(setIntersection(x,y)),a) or ~member?(sort(setUnion(x,y)),a) then return false
    true

(4) -> t([[]], [])
   (4)  true
                                                            Type: Boolean
(5) -> t([[],[1]], [1])
   (5)  true
                                                            Type: Boolean
(6) -> t([[],[1],[2,1]], [1,2])
   (6)  true
                                                            Type: Boolean
(7) -> t([[],[1],[2,3],[1,2,3]], [3,1,2])
   (7)  true
                                                            Type: Boolean
(8) -> t([[1], [1,2,3], [1,4,5,6], [1,2,3,4,5,6], [], [2,3], [4,5,6], [2,3,4,5,6]], [1,2,3,4,5,6])
   (8)  true
                                                            Type: Boolean
(9) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5], [1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [1,2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (9)  true
                                                            Type: Boolean
(10) -> t([[], [1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5], [1,2,3,4,5,6], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8], [1,2,3,4,5,6,7,8,9]], [1,2,3,4,5,6,7,8,9])
   (10)  true
                                                            Type: Boolean
(11) -> t([[], [1], [1,2,3], [1,2,3,4,5], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8,9]], [1,2,3,4,5,6,7,8,9])
   (11)  true
                                                            Type: Boolean
(2) -> t([[1]], [1])
   (2)  false
                                                            Type: Boolean
(4) -> t([[],[2]], [1,2])
   (4)  false
                                                            Type: Boolean
(5) -> t([[],[1,2],[2,3]], [1,2,3])
   (5)  false
                                                            Type: Boolean
(6) -> t([[],[1],[1,2],[2,3],[1,2,3]], [1,2,3])
   (6)  false
                                                            Type: Boolean
(7) -> t([[],[1],[2],[3],[1,2],[2,3],[1,2,3]] , [1,2,3])
   (7)  false
                                                            Type: Boolean
(8) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5],[1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (8)  false
                                                            Type: Boolean
(9) -> t([[], [1], [2], [1,2,3], [1,2,3,4,5], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8,9]] , [1,2,3,4,5,6,7,8,9])
   (9)  false
                                                            Type: Boolean
(10) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5],[1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (10)  false
                                                            Type: Boolean