Tantangan

Mengingat satu set Tdari himpunan bagian dari himpunan berhingga S={1,2,3,...,n}, menentukan apakah Tmerupakan topologi atau tidak.

Penjelasan

The Powerset P(S) dari beberapa set Sadalah himpunan semua himpunan bagian dari S. Beberapa contoh:

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

Sebuah topologi T di set Sadalah bagian dari P(S)dengan sifat sebagai berikut:

• {}ada di Tdan Sada diT
• Jika Adan Bberada di dalam Tmaka persimpangan mereka jugaA ∩ B
• Jika Adan Bberada di dalam Tbegitu juga serikat mereka A ∪ B*

_{^{* Definisi ini tidak sepenuhnya benar, tetapi itu benar untuk set yang terbatas, yang cukup untuk keperluan tantangan ini. Aksioma yang sebenarnya akan memungkinkan untuk serikat yang tak terbatas juga, tetapi itu tidak relevan dalam kasus yang terbatas.}}

Detail

• Anda dapat mengasumsikan bahwa S = {1,2,...,n}(atau sebagai alternatif S = {0,1,...,n}) di mana nbilangan bulat terbesar yang muncul di set T.
• Format input fleksibel: Anda dapat menggunakan string, daftar daftar atau set daftar atau format serupa yang dapat ditangani oleh bahasa Anda. Anda juga dapat menggunakan set seperti S = {0,1,...,n}jika lebih nyaman.
• Outputnya harus benar atau salah.
• Anda diizinkan untuk mengambil n(atau sebagai alternatif n+1atau n-1) sebagai input tambahan.
• Jika Anda bekerja dengan daftar yang diurutkan, Anda dapat mengasumsikan bahwa angka-angka dalam suatu set diurutkan. Anda juga dapat mengasumsikan bahwa daftar tersebut memiliki urutan tertentu (misalnya leksikografis.
• Saat kami mewakili set, Anda dapat mengasumsikan bahwa tidak ada dua entri dari representasi-daftar yang sama.

Contohnya

Topologi

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

non-Topologi

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

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]

Cobalah online!

Output melalui kode keluar

Haskell , 95 89 74 78 byte

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

Cobalah online!

Penjelasan:

                              ([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 byte

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

Dibawa [T, n]sebagai input.

Penjelasan

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

Fungsi yang mengembalikan persimpangan dan penyatuan input

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

Peta yang berfungsi ke daftar input di level 1.

... ~Flatten~2

Ratakan hasilnya ( Outerbagian mengembalikan sekelompok bersarang List).

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

Ambil persatuan antara daftar yang diratakan dan {{}, S}. Ini menghapus duplikat dan menambah {}dan Ske daftar yang dihasilkan.

... ==#⋃#

Periksa apakah daftar dari atas sama dengan versi input yang diurutkan.

MATL , 38 byte

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

Input adalah matriks biner di mana setiap baris adalah set, setiap kolom adalah elemen, dan setiap entri menunjukkan keanggotaan. Misalnya, {{},{1},{1,2}}dinyatakan sebagai [0 0;1 0;1 1]. Gunakan program Oktaf tertaut untuk mengkonversi ke format ini.

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

!        % 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 byte

• Terima kasih banyak kepada @ovs untuk pengurangan 19 byte yang berat: &dan |singkatan untuk operasi yang ditetapkan.
• Terima kasih @ notjagan selama 5 byte
• Terima kasih kepada @ovs untuk 2 byte: set()asi-i

Lambda yang mengambil daftar set sebagai input, dan mengembalikan Benar / salah. Cukup periksa apakah ada set kosong dan persatuan dan persimpangan setiap set (dua set iterated sebagai idan j) ada di daftar set yang diberikan.

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])

Cobalah online!

CJam (23 byte)

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

Test suite online . Ini adalah blok anonim (fungsi). Saya berasumsi S = {0,1,...,n}; blok mengambil array array yang diurutkan dan n+1sebagai parameter dan pergi 0atau 1di stack. Dalam hal {{}}kode dan kerangka kerja pengujian mengasumsikan itu n+1 = 0.

Pyth, 24 23 byte

q@aasm,@Fd{Ssd*QQYJUEyJ

Suite uji

Program ini mengambil input sebagai daftar daftar yang dipesan. Daftar dalam harus dalam urutan menaik dan daftar urutan harus diurutkan berdasarkan panjang kemudian secara leksikografis. Saya telah mengkonfirmasi bahwa ini adalah format input yang diperbolehkan. Angka mulai dari 0, dan N +1 juga diambil sebagai input.

Adapun cara kerjanya, kami menyaring apa pun yang tidak dalam P (S), lalu menambahkan S,, []persimpangan setiap pasangan dan penyatuan setiap pasangan, deduplicate, dan memeriksa bahwa hasilnya sama dengan input.

Aksioma, 358 byte

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 dan hasil:

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