Défi

Étant donné un ensemble Tde sous-ensembles d'un ensemble fini S={1,2,3,...,n}, déterminez s'il Ts'agit d'une topologie ou non.

Explication

Le jeu P(S) de puissance d'un ensemble Sest l'ensemble de tous les sous-ensembles de S. Quelques exemples:

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

Une topologie T sur l'ensemble Sest un sous-ensemble P(S)avec les propriétés suivantes:

• {}est Tet SestT
• Si Aet Bsont Tdedans, leur intersection l'est aussiA ∩ B
• Si Aet Bsont Tlà, leur union l'est aussi A ∪ B*

_{^{* Cette définition n'est pas tout à fait correcte, mais elle est vraie pour les ensembles finis, ce qui est suffisant pour les besoins de ce défi. L'axiome réel permettrait également des unions infinies, mais cela n'est pas pertinent dans le cas fini.}}

Détails

• Vous pouvez supposer que S = {1,2,...,n}(ou alternativement S = {0,1,...,n}) où nest le plus grand entier qui apparaît dans les ensembles de T.
• Le format d'entrée est flexible: vous pouvez utiliser une chaîne, une liste de listes ou un ensemble de listes ou tout autre format similaire que votre langage peut gérer. Vous pouvez également utiliser des ensembles comme S = {0,1,...,n}si c'était plus pratique.
• La sortie doit être vraie ou falsey.
• Vous êtes autorisé à prendre n(ou alternativement n+1ou n-1) comme entrée supplémentaire.
• Si vous travaillez avec des listes ordonnées, vous pouvez supposer que les numéros d'un ensemble sont triés. Vous pouvez également supposer que la liste a un certain ordre (par exemple lexicographique.
• Comme nous représentons des ensembles, vous pouvez supposer que deux entrées de leur représentation de liste ne sont pas égales.

Exemples

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

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

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]

Essayez-le en ligne!

La sortie se fait via le code de sortie

Haskell , 95 89 74 78 octets

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

Essayez-le en ligne!

Explication:

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

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

Prend [T, n]en entrée.

Explication

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

Fonction qui renvoie l'intersection et l'union des entrées

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

Mappez cette fonction sur la liste d'entrée au niveau 1.

... ~Flatten~2

Aplatissez le résultat (la Outerpièce renvoie un tas de Lists imbriqués ).

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

Prenez l'union entre la liste aplatie et {{}, S}. Cela supprime les doublons et ajoute {}et Sà la liste résultante.

... ==#⋃#

Vérifiez si la liste ci-dessus est égale à la version triée de l'entrée.

MATL , 38 octets

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

L'entrée est une matrice binaire où chaque ligne est un ensemble, chaque colonne est un élément et chaque entrée indique l'appartenance. Par exemple, {{},{1},{1,2}}est exprimé comme [0 0;1 0;1 1]. Utilisez le programme Octave lié pour convertir à ce format.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

• Merci beaucoup à @ovs pour une forte réduction de 19 octets: &et des |raccourcis pour les opérations de set.
• Merci @notjagan pour 5 octets
• Merci à @ovs pour 2 octets: set()asi-i

Lambda qui prend une liste d'ensembles en entrée et renvoie True / false. Vérifie simplement s'il y a un ensemble vide et l'union et l'intersection de chaque ensemble (deux ensembles itérés comme iet j) existe dans la liste d'ensembles donnée.

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

Essayez-le en ligne!

CJam (23 octets)

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

Suite de tests en ligne . Il s'agit d'un bloc anonyme (fonction). Je suppose S = {0,1,...,n}; le bloc prend un tableau de tableaux triés et n+1comme paramètres et quitte 0ou 1sur la pile. Dans le cas où {{}}le code et le framework de test le supposent n+1 = 0.

Pyth, 24 23 octets

q@aasm,@Fd{Ssd*QQYJUEyJ

Suite de tests

Ce programme prend l'entrée comme une liste ordonnée de listes ordonnées. Les listes internes doivent être en ordre croissant et la liste d'ordre doit être triée par longueur puis lexicographiquement. J'ai confirmé qu'il s'agit d'un format d'entrée autorisé. Les nombres commencent à 0 et N + 1 est également pris en entrée.

Quant à la façon dont cela fonctionne, nous filtrons tout ce qui n'est pas dans P (S), puis ajoutons S, []l'intersection de chaque paire et l'union de chaque paire, dédupliquons et vérifions que le résultat est égal à l'entrée.

Axiome, 358 octets

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)

non golfé et résultats:

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