Thử thách

Cho một Ttập hợp các tập hợp con của một tập hữu hạn S={1,2,3,...,n}, xác định xem có phải Tlà một cấu trúc liên kết hay không.

Giải trình

Các Powerset P(S) của một số bộ Slà tập hợp của tất cả các tập con của S. Vài ví dụ:

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

Một cấu trúc liên kết T trên tập hợp Slà một tập hợp con P(S)có các thuộc tính sau:

• {}đang ở Tvà Sđang ởT
• Nếu Avà Bđang ở Tthì giao điểm của chúng cũng vậyA ∩ B
• Nếu Avà Bđang ở Tthì liên minh của họ cũng vậy A ∪ B*

_{^{* Định nghĩa này không hoàn toàn chính xác, nhưng nó đúng với các tập hữu hạn, đủ cho mục đích của thử thách này. Tiên đề thực tế cũng sẽ cho phép các hiệp hội vô hạn, nhưng điều đó không liên quan trong trường hợp hữu hạn.}}

Chi tiết

• Bạn có thể giả sử rằng S = {1,2,...,n}(hoặc cách khác S = {0,1,...,n}) trong đó nsố nguyên lớn nhất xuất hiện trong các bộ T.
• Định dạng đầu vào rất linh hoạt: Bạn có thể sử dụng một chuỗi, danh sách danh sách hoặc bộ danh sách hoặc bất kỳ định dạng tương tự nào mà ngôn ngữ của bạn có thể xử lý. Bạn cũng có thể sử dụng các bộ như S = {0,1,...,n}nếu nó thuận tiện hơn.
• Đầu ra phải là Truthey hoặc falsey.
• Bạn được phép lấy n(hoặc thay thế n+1hoặc n-1) làm đầu vào bổ sung.
• Nếu bạn làm việc với các danh sách được sắp xếp, bạn có thể giả sử rằng các số trong một bộ được sắp xếp. Bạn cũng có thể giả định rằng danh sách này có một thứ tự nhất định (ví dụ: từ điển.
• Khi chúng tôi biểu diễn các bộ, bạn có thể giả sử rằng không có hai mục nào trong biểu diễn danh sách của chúng bằng nhau.

Ví dụ

Cấu trúc liên kết

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

phi cấu trúc

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

Hãy thử trực tuyến!

Đầu ra là thông qua mã thoát

Haskell , 95 89 74 78 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Toán học, 87 73 66 63 byte

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

Lấy [T, n]làm đầu vào.

Giải trình

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

Hàm trả về giao điểm và liên kết của các đầu vào

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

Ánh xạ chức năng đó vào danh sách đầu vào ở cấp 1.

... ~Flatten~2

Làm phẳng kết quả ( Outerphần trả về một bó Lists lồng nhau ).

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

Lấy sự kết hợp giữa danh sách làm phẳng và {{}, S}. Điều này loại bỏ trùng lặp và thêm {}và Svào danh sách kết quả.

... ==#⋃#

Kiểm tra xem danh sách từ trên có bằng với phiên bản đã sắp xếp của đầu vào không.

MATL , 38 byte

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

Đầu vào là một ma trận nhị phân trong đó mỗi hàng là một tập hợp, mỗi cột là một phần tử và mỗi mục nhập biểu thị tư cách thành viên. Ví dụ, {{},{1},{1,2}}được thể hiện như [0 0;1 0;1 1]. Sử dụng chương trình Octave được liên kết để chuyển đổi sang định dạng này.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

• Cảm ơn rất nhiều đến @ovs về việc giảm 19 byte nặng nề: &và tốc |ký cho các hoạt động thiết lập.
• Cảm ơn @notjagan cho 5 byte
• Cảm ơn @ovs cho 2 byte: set()nhưi-i

Lambda lấy danh sách các bộ làm đầu vào và trả về True / false. Đơn giản chỉ cần kiểm tra nếu có một tập hợp trống và liên kết và giao điểm của mỗi bộ (hai bộ được lặp là ivà j) tồn tại trong danh sách các bộ đã cho.

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

Hãy thử trực tuyến!

CJam (23 byte)

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

Bộ kiểm tra trực tuyến . Đây là một khối ẩn danh (chức năng). Tôi giả sử S = {0,1,...,n}; khối lấy một mảng các mảng được sắp xếp và n+1làm tham số và rời khỏi 0hoặc 1trên ngăn xếp. Trong trường hợp {{}}mã và khung kiểm tra giả định rằng n+1 = 0.

Bình thường, 24 23 byte

q@aasm,@Fd{Ssd*QQYJUEyJ

Bộ kiểm tra

Chương trình này lấy đầu vào là một danh sách có thứ tự của danh sách được sắp xếp. Các danh sách bên trong phải theo thứ tự tăng dần và danh sách thứ tự phải được sắp xếp theo chiều dài sau đó theo từ vựng. Tôi đã xác nhận rằng đây là một định dạng đầu vào được phép. Các số bắt đầu từ 0 và N + 1 cũng được lấy làm đầu vào.

Về cách thức hoạt động, chúng tôi lọc bất kỳ thứ gì không có trong P (S), sau đó thêm S, []giao điểm của mọi cặp và liên kết của mỗi cặp, lặp lại và kiểm tra xem kết quả có bằng với đầu vào không.

Tiên đề, 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)

vô dụng và kết quả:

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