Zad 1.
----------------------------------
msum x = sum $ map sum (map (\j -> map (\i -> if i/=j then (x!!j!!i)-i+j else (-1)^(x!!j!!i)) [0..(length x)-1]) [0..(length (x!!0))-1])

Zad 2.
----------------------------------

type Vector = [Float]

norm :: Vector -> Float
norm v = sqrt $ sum $ map (^2) v

psub :: Num a => (a, a) -> a
psub (a, b) = a - b

vsub :: Vector -> Vector -> Vector
vsub v1 v2 = map psub $ zip v1 v2

perm :: Vector -> Vector
perm v = (tail v) ++ [head v]

infperm :: Vector -> [Vector]
infperm v = [perm v] ++ (infperm $ perm v)

perms :: Vector -> [Vector]
perms x = take ((length x) - 1) $ infperm x

test :: Vector -> Int
test x = sum [1 | u <- perms x, (norm (vsub x u )) > 0.6 * (norm x)]


Zad 3.
----------------------------------
data Frac = Num Int Int | NaN
               deriving (Eq)

instance Show Frac where
    show NaN = "NaN"
    show (Num _ 0) = show NaN

    show (Num a b) | b == 1           = show a
                   | a == b           = show 1
                   | otherwise        = show a ++ "/" ++ show b

(.+) :: Frac -> Frac -> Frac
(Num a b) .+ (Num c d) = Num (a*d + c*b) (b*d)

(.-) :: Frac -> Frac -> Frac
(.-) (Num a b) (Num c d) = Num (a*d - c*b) (b*d)

(.*) :: Frac -> Frac -> Frac
(.*) (Num a b) (Num c d) = Num (a*c) (b*d)

(./) :: Frac -> Frac -> Frac
(./) (Num a b) (Num c d) = Num (a*d) (b*c)

-- Molimo, ne mijenjati kod ispod
main :: IO()
main = do i <- getLine
          let a = read i :: Int
          i <- getLine
          let b = read i :: Int
          i <- getLine
          let c = read i :: Int
          i <- getLine
          let d = read i :: Int
          print $ (Num a b) .+ (Num c d)
          print $ (Num a b) .- (Num c d)
          print $ (Num a b) .* (Num c d)
          print $ (Num a b) ./ (Num c d)



Zad 4.
----------------------------------

import Data.Char
d2i xs = foldl(\a x -> 10*a + digitToInt x) 0 xs
slova = "abcdefghijklmnopqrstuvwxyz"
uniq [] = []
uniq (x:xs) = [x] ++ uniq (filter (\e -> e /=x) xs)
isWord xs = and [x `elem` slova | x <- xs]
isnumb xs = and [x `elem` "0123456789" | x <- xs]
same' xs ys = concat[['1'] | x <- xs , y <- ys , x == y]
same x y = same' (uniq x) y
f' lastword broj rj num = do if (d2i num) `mod` 2 == 1 then
                                 do rijec <- getLine
                                    if isWord rijec && length rijec == (d2i num) then
                                        f lastword (broj+1) (rj ++ (same lastword rijec))
                                    else
                                        f' lastword broj rj num
                                    else
                                        do rijec <- getLine
                                           if isWord rijec && length rijec == (d2i num) then
                                                f rijec (broj+1) rj
                                           else
                                                f' lastword broj rj num

f lastword broj rj = do num <- getLine
                        if not (isnumb num) then
                            f lastword broj rj
                        else
                            if d2i num == 0 then
                                return (d2i rj)
                            else
                                if (d2i num) `mod` 2 == (broj `mod` 2) then
                                    f' lastword broj rj num
                                else
                                    f lastword broj rj


main :: IO()
main = do sol <- f "" 0 ""
          print(sol)