चुनौती

एक सेट को देखते हुए Tएक परिमित सेट के सबसेट के S={1,2,3,...,n}निर्धारित करता है कि Tएक है टोपोलॉजी है या नहीं।

व्याख्या

कुछ सेट का अधिकार सभी उपसमूह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}}

सेट पर एक टोपोलॉजी निम्नलिखित गुणों के साथ एक सबसेट है :TSP(S)

{}में है Tऔर Sअंदर हैT
अगर है Aऔर Bहै Tतो उनका चौराहा हैA ∩ B
यदि Aऔर Bमें हैं Tतो उनके संघ है A ∪ B*

_{^{* यह परिभाषा काफी सही नहीं है, लेकिन यह परिमित सेट के लिए सही है, जो इस चुनौती के उद्देश्यों के लिए पर्याप्त है। वास्तविक स्वयंसिद्ध अनंत संघों के लिए भी अनुमति देगा, लेकिन यह परिमित मामले में अप्रासंगिक है।}}

विवरण

आप मान सकते हैं कि S = {1,2,...,n}(या वैकल्पिक रूप से S = {0,1,...,n}) nसबसे बड़ा पूर्णांक कहां है जो के सेट में दिखाई देता है T।
इनपुट प्रारूप लचीला है: आप एक स्ट्रिंग, सूचियों की सूची या सूचियों के सेट या किसी भी समान प्रारूप का उपयोग कर सकते हैं जिसे आपका लैंगगॉव संभाल सकता है। आप सेट का उपयोग भी कर सकते हैं जैसे S = {0,1,...,n}कि यह अधिक सुविधाजनक है।
आउटपुट ट्रूथी या फाल्सी होना चाहिए।
आप लेने के लिए अनुमति दी जाती है n(या वैकल्पिक रूप n+1या n-1एक अतिरिक्त इनपुट के रूप में)।
यदि आप ऑर्डर की गई सूचियों के साथ काम करते हैं, तो आप मान सकते हैं कि एक सेट के भीतर संख्याओं को क्रमबद्ध किया गया है। आप यह भी मान सकते हैं कि सूची में एक निश्चित क्रम है (जैसे लेक्सिकोग्राफ़िक)।
जैसा कि हम सेट का प्रतिनिधित्व करते हैं, आप मान सकते हैं कि उनकी सूची-प्रतिनिधित्व की कोई दो प्रविष्टियाँ समान नहीं हैं।

उदाहरण

टोपोलोजी

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

गैर टोपोलॉजी

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

— flawr
स्रोत

2

ऐसा लगता है कि इस प्रश्न के बहुत सारे उत्तर इनपुट {{}, {2}} पर होंगे, क्योंकि वे स्पष्ट रूप से यह नहीं जांचते हैं कि S उस इनपुट के लिए सेट में है, S को स्पष्ट रूप से {1 माना जाता है। 2}। क्या यह ऐनक का मान्य वाचन है, या मैं कुछ याद कर रहा हूँ?

— कारमिस्टर जूल

@Carmeister भ्रम के लिए क्षमा करें, हाँ आपकी व्याख्या सही है!

— दोष

क्या इनपुट एक बाइनरी मैट्रिक्स हो सकता है जहां प्रत्येक पंक्ति एक सेट है, प्रत्येक कॉलम एक तत्व है, और मान इंगित करता है कि क्या तत्व सेट में है?

— लुइस मेंडू

हां मुझे लगता है कि स्वीकार्य है।

— दोष

चूंकि Tएक सेट है, मुझे लगता है कि यह मानना उचित है कि इनपुट में कोई सबसेट दोहराया {{}, {1,2}, {1,2}}नहीं जाता है (यानी वैध इनपुट नहीं है)। क्या आप स्पष्ट कर सकते हैं कि चुनौती में, सकारात्मक या नकारात्मक रूप से?

— लुइस मेंडू

7

अजगर 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]

इसे ऑनलाइन आज़माएं!

आउटपुट निकास कोड के माध्यम से है

— OVS
स्रोत

5

हास्केल , 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

— flawr
स्रोत

किस बारे में [[],[2]]? यह एक टोपोलॉजी है, लेकिन निहित नहीं ("आप मान सकते हैं कि ...") सेट पर।

— क्रिश्चियन सेवर्स

@ChristianSievers सही हुए!

— 19

5

गणितज्ञ, 87 73 66 63 बाइट्स

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

[T, n]इनपुट के रूप में लेता है ।

व्याख्या

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

फ़ंक्शन जो चौराहे और आदानों के संघ को वापस करता है

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

मानचित्र जो 1 स्तर पर इनपुट सूची पर कार्य करता है।

... ~Flatten~2

परिणाम को समतल करें ( Outerभाग नेस्टेड Listएस का एक गुच्छा लौटाता है )।

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

चपटी सूची के बीच संघ को ले लो और {{}, S}। यह डुप्लिकेट दूर करता है और कहते हैं {}और Sजिसके परिणामस्वरूप सूची में।

... ==#⋃#

जांचें कि ऊपर से सूची इनपुट के सॉर्ट किए गए संस्करण के बराबर है या नहीं।

— जंगहवान मिन
स्रोत

4

MATL , 38 बाइट्स

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

इनपुट एक बाइनरी मैट्रिक्स है जहां प्रत्येक पंक्ति एक सेट है, प्रत्येक कॉलम एक तत्व है, और प्रत्येक प्रविष्टि सदस्यता को इंगित करता है। उदाहरण के लिए, के {{},{1},{1,2}}रूप में व्यक्त किया जाता है [0 0;1 0;1 1]। इस प्रारूप में कनवर्ट करने के लिए लिंक किए गए ऑक्टेव प्रोग्राम का उपयोग करें ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

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

— लुइस मेंडो
स्रोत

1

D: आपका कार्यक्रम आपके शीर्षक से अधिक स्थान लेता है!

— दोष

3

पायथन 2 , 92 71 122 बाइट्स

एक भारी 19 बाइट्स में कमी के लिए @ovs को बहुत धन्यवाद: &और |सेट ऑपरेशन के लिए शॉर्टहैंड।
5 बाइट्स के लिए @notjagan को धन्यवाद
@ बाइट्स 2 बाइट्स के लिए धन्यवाद: के set()रूप मेंi-i

लैम्ब्डा जो इनपुट के रूप में सेट की एक सूची लेता है, और ट्रू / गलत लौटाता है। बस जाँच करता है कि क्या कोई खाली सेट है और प्रत्येक सेट के संघ और चौराहे (दो सेट के रूप में पुनरावृत्त ) 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])

इसे ऑनलाइन आज़माएं!

— officialaimm
स्रोत

1

71 बाइट्स

— ओव्स

@ नोव्स बहुत बहुत धन्यवाद, शॉर्टहैंड को नहीं जानते थे!

— आधिकारिक

@ovs मैं वास्तव में स्पष्ट रूप से सूची आइटम परिवर्तित कर रहा हूँ input()करने के लिए set()पाद लेख में।

— आधिकारिक

1

66 बाइट्स।

— नॉटजैगन

1

आप बदल सकते हैं set()के साथ i-iयाi^i

— OVS

2

CJam (23 बाइट्स)

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

ऑनलाइन टेस्ट सूट । यह एक अनाम ब्लॉक (फ़ंक्शन) है। मैं मान लेता हूं S = {0,1,...,n}; ब्लॉक सॉर्ट किए गए सरणियों की एक सरणी लेता है और n+1मापदंडों और पत्तियों के रूप में 0या 1स्टैक पर। मामले {{}}में कोड और परीक्षण रूपरेखा मान लेते हैं n+1 = 0।

— पीटर टेलर
स्रोत

2

पायथ, 24 23 बाइट्स

q@aasm,@Fd{Ssd*QQYJUEyJ

परीक्षण सूट

यह कार्यक्रम आदेशित सूचियों की सूची के रूप में इनपुट लेता है। आंतरिक सूचियों को बढ़ते क्रम में होना चाहिए और क्रम सूची को लंबाई द्वारा क्रमबद्ध किया जाना चाहिए। मैंने पुष्टि की है कि यह एक अनुमत इनपुट प्रारूप है। नंबर 0 से शुरू होते हैं, और N + 1 को इनपुट के रूप में भी लिया जाता है।

जैसा कि यह कैसे काम करता है, हम पी (एस) में कुछ भी फ़िल्टर नहीं करते हैं, फिर एस,, []हर जोड़ी के प्रतिच्छेदन और प्रत्येक जोड़ी के संघ को जोड़ते हैं , समर्पण करते हैं, और जांचते हैं कि परिणाम इनपुट के बराबर है।

— isaacg
स्रोत

0

Axiom, 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)

अपुष्ट और परिणाम:

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

— RosLuP
स्रोत

टोपोलॉजी सत्यापित करें

चुनौती

व्याख्या

विवरण

उदाहरण

अजगर 2 , 117 99 97 91 बाइट्स

हास्केल , 95 89 74 78 बाइट्स

गणितज्ञ, 87 73 66 63 बाइट्स

व्याख्या

MATL , 38 बाइट्स

व्याख्या

पायथन 2 , 92 71 122 बाइट्स

CJam (23 बाइट्स)

पायथ, 24 23 बाइट्स

Axiom, 358 बाइट्स