চ্যালেঞ্জ

একটি সেট দেওয়া 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}}

একজন টপোলজি 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}) কোথায় 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

দেখে মনে হচ্ছে এই প্রশ্নের অনেকগুলি উত্তর ইনপুট would {}, {2} on এ আসবে কারণ তারা স্পষ্টভাবে তা পরীক্ষা করে না যে এস ইনপুটটির সময় সেটটিতে রয়েছে, এস স্পষ্টতই ধরে নেওয়া হয়েছে যে {1, 2}। এটি কি চশমাগুলির বৈধ পঠন, বা আমি কিছু মিস করছি?

— Carmeister

@ কারমিস্টার বিভ্রান্তির জন্য দুঃখিত, হ্যাঁ আপনার ব্যাখ্যাটি সঠিক!

— flawr

ইনপুট কি বাইনারি ম্যাট্রিক্স হতে পারে যেখানে প্রতিটি সারি একটি সেট থাকে, প্রতিটি কলামই একটি উপাদান এবং মানটি নির্দেশ করে যে উপাদানটি সেটে রয়েছে কিনা?

— লুইস মেন্ডো

হ্যাঁ আমি মনে করি এটি গ্রহণযোগ্য।

— flawr

যেহেতু Tএকটি সেট, আমি ধারণা করি যে ইনপুটটিতে কোনও উপসেট পুনরাবৃত্তি হয়নি (যেমন {{}, {1,2}, {1,2}}বৈধ ইনপুট নয়) it's আপনি কি চ্যালেঞ্জের মধ্যে তা সুনির্দিষ্টভাবে বা নেতিবাচকভাবে পরিষ্কার করতে পারবেন?

— লুইস মেন্ডো

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]]? এটি টপোলজি, তবে অন্তর্নিহিত ("আপনি ধরে নিতে পারেন যে ...") সেটটি নয়।

— ক্রিশ্চিয়ান সিভারস

@ খ্রিস্টিয়ানসিভার সংশোধন করেছেন!

— flawr

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

এমএটিএল , 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

ডি: আপনার প্রোগ্রামটি আপনার শিরোনামের চেয়ে বেশি জায়গা নেয়!

— flawr

3

পাইথন 2 , 92 71 122 বাইট

ভারী 19 বাইট হ্রাস জন্য @ ওভসকে অনেক ধন্যবাদ: &এবং |সেট অপারেশনের জন্য শর্টহ্যান্ডস।
ধন্যবাদ 5 নোটজাগান 5 বাইটের জন্য
@ ওভসকে 2 বাইটের জন্য ধন্যবাদ: set()যেমনi-i

লাম্বদা যে ইনপুট হিসাবে সেটগুলির একটি তালিকা নেয় এবং সত্য / মিথ্যা প্রত্যাবর্তন করে। কেবলমাত্র চেক যদি সেখানে একটি ফাঁকা সেট এবং ইউনিয়ন ও প্রতিটি সেট ছেদ হয় (দুই সেট হিসাবে iterated 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

@ovs অনেক ধন্যবাদ, সংক্ষিপ্ত বিবরণ জানতেন না!

— অফিসিয়ালাইম

@ovs আমি আসলে স্পষ্টভাবে তালিকা থেকে আইটেম রূপান্তর করছি input()করার set()ফুটার মধ্যে।

— অফিসিয়ালাইম

1

66 বাইট।

— notjagan

1

আপনি প্রতিস্থাপন করতে পারেন set()সঙ্গে i-iবাi^i

— ovs

2

সিজেএম (23 বাইট)

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

অনলাইন পরীক্ষা স্যুট । এটি একটি বেনামে ব্লক (ফাংশন)। আমি ধরে নিই S = {0,1,...,n}; ব্লকটি বাছাই করা অ্যারেগুলির একটি অ্যারে নেয় এবং n+1পরামিতি এবং পাতাগুলি হিসাবে 0বা 1স্ট্যাকের উপরে। ক্ষেত্রে {{}}কোড এবং পরীক্ষার কাঠামোটি এটি ধরে নেয় n+1 = 0।

— পিটার টেলর
সূত্র

2

পাইথ, 24 23 বাইট

q@aasm,@Fd{Ssd*QQYJUEyJ

পরীক্ষা স্যুট

এই প্রোগ্রামটি অর্ডার করা তালিকার একটি আদেশযুক্ত তালিকা হিসাবে ইনপুট নেয়। অভ্যন্তরীণ তালিকাগুলি অবশ্যই আরোহী ক্রমে থাকতে হবে এবং ক্রম তালিকাটি লিক্সোগ্রাফিকভাবে দৈর্ঘ্য অনুসারে বাছাই করতে হবে। আমি নিশ্চিত করেছি যে এটি একটি অনুমোদিত ইনপুট ফর্ম্যাট। নম্বরগুলি 0 থেকে শুরু হয় এবং এন + 1 এছাড়াও ইনপুট হিসাবে নেওয়া হয়।

এটি কীভাবে কাজ করে তা হিসাবে, আমরা পি (এস) এ নয় এমন কোনও ফিল্টার আউট করি, তারপরে এস যুক্ত করুন, []প্রতিটি জোড়ের ছেদ এবং প্রতিটি জোড়ের মিলন, প্রতিলিপি তৈরি করুন এবং ফলাফলটি ইনপুটটির সমান কিনা তা পরীক্ষা করুন।

— isaacg
সূত্র

0

অ্যাক্সিয়াম, 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 বাইট

ব্যাখ্যা

এমএটিএল , 38 বাইট

ব্যাখ্যা

পাইথন 2 , 92 71 122 বাইট

সিজেএম (23 বাইট)

পাইথ, 24 23 বাইট

অ্যাক্সিয়াম, 358 বাইট