module Work where
 --ex.: 4
 metades :: [a] -> ([a],[a])
 metades l = (esq,dir)
         where
            n1 = length l `div` 2
            esq = take n1 l
            dir = drop n1 l

 --ex.: 8
 maxOccurs :: Integer -> Integer -> (Integer,Integer)
 maxOccurs a b | a > b = (a,1)
               | a < b = (b,1)
               | otherwise = (a,2)

 orderTriple :: (Integer,Integer,Integer) -> (Integer,Integer,Integer)
 orderTriple (a,b,c) | (a > b) && (b > c) = (c,b,a)
                     | (b > a) && (a > c) = (c,a,b)
                     | (b > c) && (c > a) = (a,c,b)
                     | otherwise = (b,a,c)

 --ex.: 24
 divprop :: Int -> [Int]
 divprop x = [n | n <- [1..x-1], mod x n == 0]

 --ex.: 26
 primo :: Int -> Bool
 primo n = length [x | x <- [1..n], mod n x == 0] == 2

 --ex.: 29
 pitagoricos :: Int -> [(Int,Int,Int)]
 pitagoricos n = [(x,y,z) | x <- [1..n], y <- [1..n], z <- [1..n], x^2 + y^2 == z^2]

 --ex.: 30
 factorial :: Int -> Int
 factorial 0 = 1
 factorial n = n* factorial (n-1)

 rangeProduct :: Int -> Int -> Int
 rangeProduct n m | n == m = n
                  | n > m = m * rangeProduct n (m+1)

 --ex.: 38
 myreplicate :: Int -> a -> [a]
 myreplicate 0 x = []
 myreplicate n x = x : myreplicate (n-1) x

 --ex.: 40  !!! NÃO SEI FAZER !!!
 --forte :: String -> Bool
 --forte cs = length [c,s,v | c<-cs isLower c, s<-cs isUpper s, v<-cs isDigit v] >= 8

 --ex.: 41
 delete :: Eq a => a -> [a] -> [a]
 delete x []      = []
 delete x (y:ys) | x == y = delete x ys
                 | otherwise = y:delete x ys

 --ex.: 42
 myinter :: a -> [a] -> [a]
 myinter x [] = []
 myinter x [y] = [y]
 myinter x (y:ys) = y:x:myinter x ys

 --ex.: 43
 insert :: Ord a => a -> [a] -> [a]
 insert x [] = [x]
 insert x (y:ys) | x <= y = (x:y:ys)
                 | otherwise = y:insert x ys

 isort :: Ord a => [a] -> [a]
 isort [] = []
 isort (x:xs) = insert x (isort xs)

 --ex.: 44
 minimum' :: Ord a => [a] -> a
 minimum' [x] = x
 minimum' (x:xs) = minimum_aux x xs
      where
        minimum_aux :: Ord a => a -> [a] -> a
        minimum_aux x [] = x
        minimum_aux x (y:ys) | x <= y = minimum_aux x ys
                             | x > y = minimum_aux y ys

 minimum :: Ord a => [a] -> a
 minimum [x] = x
 minimum (x:y:xs) | x <= y = minimum' (x:xs)
                  | x > y = minimum' (y:xs)

 mydelete :: Eq a => a -> [a] -> [a]
 mydelete x [] = []
 mydelete x (y:ys) | x == y = ys
                   | otherwise = y:mydelete x ys

 ssort :: Ord a => [a] -> [a] -- !!! NÃO SEI FAZER !!!
 ssort [] = []
 ssort l = m : ll
       where
        m = minimum' l
        ll = ssort (delete m l)

 --ex.: 45
 merge :: Ord a => [a] -> [a] -> [a]
 merge l1 [] = l1
 merge [] l2 = l2
 merge (x:xs) (y:ys) | x <= y = x:merge xs (y:ys)
                     | x > y = y:merge (x:xs) ys

 mymetades :: [a] -> ([a],[a])
 mymetades [] = ([],[])
 mymetades l = (l1,l2)
         where
            n = div (length l) 2
            l1 = take n l
            l2 = drop n l
 --msort :: Ord a => [a] -> [a] -- !!! NÃO SEI FAZER !!!
 --msort [] = []
 --msort [x] = [x]
 --msort l = (merge l1) (merge l2)
       --where
         --(l1,l2) = mymetades l

 --ex.: 47 !!! NÃO SEI FAZER !!!
 permutations :: Eq a => [a] -> [[a]]
 permutations [] = []
 permutations xs = [i:j | i <- xs, j <- permutations $ delete i xs ]

 --ex.: 48
 combo :: (a -> b) -> (a -> Bool) -> [a] -> [b]
 combo f p xs = map f (filter p xs)

 --ex.: 51
 myzipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
 myzipWith _ [] [] = []
 myzipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys

 --ex.:53
 shift :: [a] -> Int -> [a]
 shift l n = drop n l  ++ take n l
 rotate :: [a] -> [[a]]
 rotate l = [shift l i | i <- [0 .. (length l) -1]]