{-
WIELOLINIJKOWY
KOMENTARZ
-}
--zadanie1
let f xs = [k | k <- xs, k `mod` (head xs) /= 0]
let l = f [2..]

let primes = map head (iterate f l)

--zadanie2
primes' = 2:[p | p <- [3..], all (\x -> p `mod` x /= 0) (takeWhile (\x -> x*x <= p) primes')]

--zadanie3
let fib = 1:1:(zipWith (+) fib (tail fib))


--zadanie4
:{
iperm :: [a] -> [[a]]
iperm [] = [[]]
iperm (x:xs) =
    foldr (++) [] (map (insert [] x) (iperm xs))
    where
        insert :: [a] -> a -> [a] -> [[a]]
        insert xs x [] = [xs ++ [x]]
        insert xs x (y:ys) =
            (xs ++ (x : y : ys)) : (insert (xs ++ [y]) x ys)
:}

insEv :: a -> [a] -> [[a]]
insEv x [] = [[x]]
insEv x (ys as (y:ys')) = (x:ys):[y:zs | zs <- insEv x ys'] (lub map (y:) (insEv x ys'))
(list comprehension to inna skladnia na concatmapa)

iperm (x:xs) = [p' | p' <- insEv x p, p <- iperm xs]


select
chcemy uzyskac element i reszte elementow
split :: [a] -> [(a,[a])]
split [x] = [(x, [])]
split x:xs = (x:xs):[(y,x:ys) | (y,ys) <- split xs]

sperm [] -> [[]]
sperm xs = [x:p | (x, r) <- split xs, p<- sperm r]


--zadanie5
:{
sublist :: [a] -> [[a]]
sublist [] = [[]]
sublist (x:xs) = let sxs = sublist xs in (map (\ys -> x:ys) sxs) ++ sxs
:}
sublist (x:xs) = [x:sub | sub <- subs] ++ subs where subs = sublist xs

--zadanie6
--to jest zip
diagonal _ [] = []
diagonal [] _ = []
diagonal (x:xs) (y:ys) = (x,y):(diagonal xs ys)

walk xs rys (y:ys) = (diagonal xs rys):(walk xs (y:rys) ys)
walk (x:xs) rys [] = (diagonal xs rys):(walk xs rys [])
walk [] _ _ = []

(><) xs ys = concat (walk xs [] ys)

--zadanie7
data Tree a = Node (Tree a) a (Tree a) | Leaf
data Set a = Fin (Tree a) | Cofin (Tree a)
:{

--tego brakuje
--setUnion, setIntersection :: Ord a => Set a -> Set a -> Set a
--setComplement :: Ord a => Set a -> Set a

setComplement (Fin t) = (Cofin t)
setComplement (Cofin t) = (Fin t)

--mozemy wziac wierzcholek pierwszego drzewa i podzielic drugie drzewo na dwa (mniejsze od tego elementu i wieksze od tego elementu)
-- trzeba napisac splita do dzielenia drzewa
-- potem bierzemy czesc wspolna lewego podrzewa nr 1 z lewym ktore powstalo po podzieleniu i prawego z prawym ktore powstalo
setIntersection Node (alt av art) Node (blt bv brt)
case compare av bv of
    EQ -> Node (setIntersection alt blt) av (setIntersection art brt)

--dzielenie drzewa wzgledem x
split x (Node l y r) =
    case compare x y of
    | EQ -> (l,r)
    | Lt -> let (l',r') = split x l  in (l', Node r' y r)
    | Gt -> let (l',r') = split x r in (Node l y l', r')

tunion Leaf t = t
tunion (Node l x r) t = Node (tunion l l') x (tunion r, r')
    where (l',r') = split x t

tintersection --donapisania

insert :: Ord a => a -> Tree a -> Tree a
insert a Leaf = Node Leaf a Leaf
insert a (Node left val right)
    | a < val = Node (insert a left) val right
    | otherwise = Node left val (insert a right)

buildTree :: Ord a => [a] -> Tree a
buildTree [] = Leaf
buildTree (x:xs) = insert x $ buildTree xs

setFromList :: Ord a => [a] -> Set a
setFromList [] = Fin Leaf
setFromList (x:xs) = Fin (buildTree (x:xs))

setEmpty :: Ord a => Set a
setEmpty = Fin Leaf

setFull :: Ord a => Set a
setFull = Cofin Leaf


setMember :: Ord a => a -> Set a -> Bool
setMember _ (Fin Leaf) = False
setMember a (Cofin s) = not (setMember a (Fin s))
setMember a (Fin (Node left val right))
    |  a == val = True
    |  otherwise = setMember a (Fin left) || setMember a (Fin right)
:}



--ZADANIE 4

iperm :: [a] -> [[a]]

iperm [] = [[]]
iperm (x:xs) =
    foldr (++) [] (map (insert [] x) (iperm xs))
    where
        insert :: [a] -> a -> [a] -> [[a]]
        insert xs x [] = [xs ++ [x]]
        insert xs x (y:ys) =
            (xs ++ (x : y : ys)) : (insert (xs ++ [y]) x ys)

sperm :: [a] -> [[a]]
sperm [] = []
sperm [x] = [[x]]
sperm xs =
    [y:zs | (y,ys) <- select xs, zs <- sperm ys]
    where
        select :: [a] -> [(a, [a])]
        select [x] = [(x, [])]
        select (x:xs) = (x, xs) : [(y, x:ys) | (y, ys) <- select xs]


--ZADANIE 5
sublist :: [a] -> [[a]]
sublist [] = [[]]
sublist (x:xs) = [x:sublists | sublists <- sublist xs] ++ sublist xs