introduzione

Nel campo della matematica noto come topologia , ci sono cose chiamate assiomi di separazione . Intuitivamente, hai un set Xe una raccolta di sottoinsiemi di Xcui possiamo pensare come proprietà. Il sistema è ben separato, se uno può distinguere tra tutti gli elementi in Xbase alle loro proprietà. Gli assiomi di separazione formalizzano questa idea. In questa sfida, il tuo compito è controllare tre assiomi di separazione, dati Xe l'elenco delle proprietà.

Ingresso

I tuoi input sono un numero intero n ≥ 2e un elenco di elenchi Tdi numeri interi. Gli interi in Tvengono estratti da X = [0, 1, ..., n-1]. Gli elenchi in Tpossono essere vuoti e non ordinati, ma non conterranno duplicati.

Produzione

L'output è una delle quattro stringhe, determinata da tre assiomi di separazione, ciascuno più forte dell'ultimo. Esistono altri assiomi, ma restiamo fedeli a questi per semplicità.

• Supponiamo che per tutti i distinti xe yin X, esiste un elenco Tcontenente esattamente uno di essi. Quindi Xe Tsoddisfa l' assioma T0 .
• Supponiamo che per tutti i distinti xe yin X, ci siano due elenchi in T, uno dei quali contiene xma non y, e l'altro contiene yma non x. Quindi Xe Tsoddisfa l' assioma T1 .
• Supponiamo che anche i due elenchi sopra non contengano elementi comuni. Quindi Xe Tsoddisfa l' assioma T2 .

L'output è uno dei T2, T1, T0o TS, a seconda di quale delle condizioni di cui sopra vale ( TSmezzo nessuno di loro lo fanno). Si noti che T2 è più forte di T1, che è più forte di T0, e si dovrebbe sempre produrre l'assioma più forte possibile.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Casi test

2 [] -> TS
2 [[],[1]] -> T0
2 [[0],[1]] -> T2
3 [[0],[0,1,2],[1,2]] -> TS
3 [[],[0],[0,1],[2]] -> T0
3 [[0],[0,1],[2,1],[0,1,2]] -> T0
3 [[0],[0,1],[2,1],[2,0]] -> T1
6 [[0,2,4],[0,3,5],[1,2],[3,4,5]] -> TS
6 [[0,2,4],[0,3,5],[1,2],[2,5],[3,4,5]] -> T0
6 [[0,2,4],[0,3,5],[1,2],[2,5],[3,1],[3,4,5]] -> T1
6 [[0,1],[0,2,3],[1,4],[2,4],[2,3,5],[1,3],[4,5]] -> T2

Haskell, 317 209 174 168 byte

La funzione f fa il lavoro.

(#)=elem
x?y=[1|a<-x,b<-y,not$any(#a)b]
f n l|t(++)="TS"|t zip="T0"|t(?)="T1"|1>0="T2"where
    t p=any null[p(x%y)(y%x)|x<-[0..n-1],y<-[0..x-1]]
    x%y=[z|z<-l,x#z,not$y#z]

test:

main=do
    putStrLn $ f 2 []
    putStrLn $ f 2 [[],[1]]
    putStrLn $ f 2 [[0],[1]]
    putStrLn $ f 3 [[0],[0,1,2],[1,2]]
    putStrLn $ f 3 [[],[0],[0,1],[2]]
    putStrLn $ f 3 [[0],[0,1],[2,1],[0,1,2]]
    putStrLn $ f 3 [[0],[0,1],[2,1],[2,0]]
    putStrLn $ f 6 [[0,2,4],[0,3,5],[1,2],[3,4,5]]
    putStrLn $ f 6 [[0,2,4],[0,3,5],[1,2],[2,5],[3,4,5]]
    putStrLn $ f 6 [[0,2,4],[0,3,5],[1,2],[2,5],[3,1],[3,4,5]]
    putStrLn $ f 6 [[0,1],[0,2,3],[1,4],[2,4],[2,3,5],[1,3],[4,5]]

produzione:

TS
T0
T2
TS
T0
T0
T1
TS
T0
T1
T2