ท้าทาย

รับชุดTย่อยของเซต จำกัดS={1,2,3,...,n}ตรวจสอบว่าTเป็นทอพอโลยีหรือไม่

คำอธิบาย

powerset P(S)ของบางชุดเป็นชุดย่อยทั้งหมดของS Sตัวอย่างบางส่วน:

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

โทโพโลยี TในชุดSเป็นส่วนหนึ่งของP(S)ที่มีคุณสมบัติดังต่อไปนี้:

• {}อยู่ในTและSอยู่ในT
• ถ้าAและBอยู่ในTนั้นก็คือจุดตัดของพวกเขาA ∩ B
• หากAและBอยู่ในTนั้นดังนั้นสหภาพของพวกเขาคือA ∪ B*

_{^{* คำจำกัดความนี้ไม่ถูกต้อง แต่เป็นจริงสำหรับเซต จำกัด ซึ่งเพียงพอสำหรับวัตถุประสงค์ของการท้าทายนี้ สัจพจน์ที่เกิดขึ้นจริงจะช่วยให้สหภาพแรงงานไม่มีที่สิ้นสุดเช่นกัน แต่นั่นไม่เกี่ยวข้องในกรณีที่ จำกัด}}

รายละเอียด

• คุณสามารถสรุปได้ว่าS = {1,2,...,n}(หรืออีกทางเลือกหนึ่งS = {0,1,...,n}) ซึ่งเป็นเลขที่ใหญ่ที่สุดที่ปรากฏในชุดของnT
• รูปแบบการป้อนข้อมูลมีความยืดหยุ่น: คุณสามารถใช้สตริงรายการของรายการหรือชุดรายการหรือรูปแบบที่คล้ายกันที่คุณสามารถจัดการได้ นอกจากนี้คุณยังสามารถใช้ชุดเช่นS = {0,1,...,n}ถ้ามันสะดวกกว่า
• ผลลัพธ์จะต้องเป็นความจริงหรือเท็จ
• คุณได้รับอนุญาตให้รับn(หรืออีกทางหนึ่งn+1หรือn-1) เป็นอินพุตเพิ่มเติม
• หากคุณทำงานกับรายการที่สั่งซื้อคุณสามารถสมมติได้ว่าตัวเลขภายในชุดนั้นเรียงลำดับแล้ว คุณสามารถสันนิษฐานได้ว่ารายการนั้นมีคำสั่งซื้อที่แน่นอน (เช่นการทำพจนานุกรม
• ในขณะที่เราเป็นตัวแทนของชุดคุณสามารถสันนิษฐานได้ว่าไม่มีรายการสองรายการของการแทนค่ารายการนั้นเท่ากัน

ตัวอย่าง

topologies

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

ไม่ใช่ Topologies

{{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 ไบต์

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]

ลองออนไลน์!

ผลลัพธ์คือรหัสทางออก

Haskell , 95 89 74 78 ไบต์

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

ลองออนไลน์!

คำอธิบาย:

                              ([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 ไบต์

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

ใช้[T, n]เป็นอินพุต

คำอธิบาย

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

ฟังก์ชันที่ส่งคืนจุดตัดและการรวมของอินพุต

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

แมปที่ฟังก์ชั่นลงในรายการอินพุตที่ระดับ 1

... ~Flatten~2

คลายผลลัพธ์ ( Outerส่วนที่ส่งคืนเป็นกลุ่มของLists ที่ซ้อนกัน)

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

{{}, S}ใช้สหภาพระหว่างรายการและแบน สิ่งนี้จะลบรายการที่ซ้ำกันและเพิ่ม{}และSไปยังรายการผลลัพธ์

... ==#⋃#

ตรวจสอบว่ารายการจากด้านบนเท่ากับรุ่นที่เรียงลำดับของอินพุต

MATL , 38 ไบต์

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

อินพุตเป็นเมทริกซ์ไบนารีที่แต่ละแถวตั้งค่าแต่ละคอลัมน์เป็นองค์ประกอบและแต่ละรายการแสดงถึงความเป็นสมาชิก ยกตัวอย่างเช่นจะแสดงเป็น{{},{1},{1,2}} [0 0;1 0;1 1]ใช้โปรแกรม Octave ที่เชื่อมโยงเพื่อแปลงเป็นรูปแบบนี้

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

!        % 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 ไบต์

• ขอบคุณมากที่ @ovs สำหรับการลดขนาดหนัก 19 ไบต์: &และ|ชวเลขสำหรับการดำเนินการที่กำหนดไว้
• ขอบคุณ @notjagan 5 ไบต์
• ขอบคุณ @ovs สำหรับ 2 ไบต์: set()asi-i

แลมบ์ดาที่รับรายการชุดเป็นอินพุตและส่งคืน True / false เพียงตรวจสอบว่ามีชุดที่ว่างเปล่าและมีการรวมและการแยกของแต่ละชุด (สองชุดซ้ำเป็นiและj) อยู่ในรายการชุดที่กำหนด

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

ลองออนไลน์!

CJam (23 ไบต์)

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

ชุดทดสอบออนไลน์ นี่คือบล็อกที่ไม่ระบุชื่อ (ฟังก์ชัน) ผมถือว่าS = {0,1,...,n}; บล็อกใช้อาร์เรย์ของอาร์เรย์ที่เรียงลำดับและn+1เป็นพารามิเตอร์และใบไม้0หรือ1บนสแต็ก ในกรณีที่รหัสและกรอบการทดสอบสมมติว่า{{}}n+1 = 0

Pyth, 24 23 ไบต์

q@aasm,@Fd{Ssd*QQYJUEyJ

ชุดทดสอบ

โปรแกรมนี้รับข้อมูลเป็นรายการสั่งซื้อของรายการสั่งซื้อ รายการด้านในจะต้องอยู่ในลำดับจากน้อยไปมากและรายการคำสั่งจะต้องเรียงตามความยาวจากนั้นพจนานุกรม ฉันยืนยันว่านี่เป็นรูปแบบอินพุตที่ได้รับอนุญาต ตัวเลขเริ่มต้นที่ 0 และยังใช้ N + 1 เป็นอินพุต

สำหรับวิธีการทำงานเรากรองสิ่งที่ไม่ได้อยู่ใน P (S) แล้วเพิ่ม S, []จุดตัดของทุกคู่และการรวมกันของทุกคู่, การขจัดข้อมูลซ้ำซ้อนและตรวจสอบว่าผลลัพธ์เท่ากับอินพุต

ความจริง 358 ไบต์

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 และผลลัพธ์:

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