main :: IO ()
main = putStrLn "Hello Haskell"

xs = [2, 3, 4, 6]
ys = sortOn Down xs  -- [6, 4, 3, 2]

ys = sort xs  -- [2, 3, 4, 6]

ys = [ x | (i, x) <- zip [0..] xs, odd i ]  -- [3, 6]

ys = [ x | (i, x) <- zip [0..] xs, even i ]  -- [2, 4]

ys = zip xs (tail xs)  -- [(2,3),(3,4),(4,6)]

pairs2 (x:y:rest) = (x,y) : pairs2 rest
pairs2 _ = []  -- [(2,3),(4,6)]

ys = [take i xs | i <- [1..length xs]]  -- [[2,3],[2,3,4],[2,3,4,6]]

import Data.Char
digits = map digitToInt(show(abs digit))  -- 1234 -> [1,2,3,4]

[ (a,b) | (a,b) <- pairs, a `rem` b == 0 ]

[ (a,b) | (i,a) <- zip [0..] ys, (j,b) <- zip [0..] ys, i < j, a `rem` b == 0 ]

[ (x,y) | x <- [1..3], y <- [4..6] ]

mapWithIndex f xs = [ f i x | (i,x) <- zip [0..] xs ]

selectiveMap p f xs = [ if p x then f x else x | x <- xs ]

zip [0..] xs  -- [(0,2),(1,3),(2,4),(3,6)]

[ (a,b) | (i,a) <- zip [0..] ys, (j,b) <- zip [0..] ys, i < j ]

divisiblePairs xs = [ (a,b) | (i,a) <- zip [0..] ys, (j,b) <- zip [0..] ys, 
                           i < j, a `rem` b == 0 ]
  where ys = sortOn Down xs

ssd xs ys = sum [ (a-b)^2 | (rowX,rowY) <- zip xs ys, (a,b) <- zip rowX rowY ]

countOdds n = show $ length $ filter odd $ digits n
  where digits 0 = []
        digits x = map read (show x)

import Data.List
commonElements xs ys = nub [x | x <- xs, x `elem` ys]

removeDiv5 :: [Int] -> [Int]
removeDiv5 = filter (\x -> x `mod` 5 /= 0)

-- Write a function which takes `a` as a first term, 
-- `d` as a common difference, and `n` as the number of terms 
-- in the arithmetic sequence, and returns the arithmetic sequence.
arithmeticSequence :: Int -> Int -> Int -> [Int]
arithmeticSequence a d n = take n $ iterate (+d) a

-- Write a function, that counts the number of vowels 
-- (a, e, i, o, u) in a given string.
-- The function should be case insensitive.
countVowels :: String -> Int
countVowels = length . filter (`elem` "aeiouAEIOU")

isPrime :: Int -> Bool
isPrime x = divisors x == [1,x]
  where
    divisors n    = filter (`divisible` n) [1..n]
    divisible d n = rem n d == 0

replaceWithOccurrence :: [Int] -> [Int]
replaceWithOccurrence xs = map (\x -> count x xs) xs
  where
    count y = length . filter (== y)

toBinary :: Int -> String
toBinary 0 = "0"
toBinary k = reverse (helper k)
helper :: Int -> String
helper 0 = []
helper y = let (q,r) = y `divMod` 2 in (if r == 0 then '0' else '1') : helper q

perfectNumbers n = [x | x <- [2..n], sum (init (divisors x)) == x]

averageScores = map (\(name, scores) -> (name, sum scores / genericLength scores))

-- Dot product of two Int lists
dotProd :: [Int] -> [Int] -> Int
dotProd xs ys = sum [ x * y | x <- xs | y <- ys ]
 
-- Average of a list (generic numeric)
avg :: (Real a, Fractional b) => [a] -> b
avg xs = realToFrac (sum xs) / fromIntegral (length xs)

{-## LANGUAGE ParallelListComp ##-}
 
-- v1 + v2 * v3, elementwise
mulAddA :: [Int] -> [Int] -> [Int] -> [Int]
mulAddA v1 v2 v3 = [ a + b * c | a <- v1 | b <- v2 | c <- v3 ]
 
-- Elementwise product and safe division
elementWise :: [Double] -> [Double] -> ([Double], [Double])
elementWise xs ys = (products, divisions)
  where
    n         = min (length xs) (length ys)
    xs'       = take n xs
    ys'       = take n ys
    products  = [ x * y           | x <- xs' | y <- ys' ]
    divisions = [ if y == 0 then 0 else x / y
                | x <- xs' | y <- ys' ]

-- Combine tuples with Int and Bool
processTuples :: [(Int,Bool)] -> [(Int,Bool)] -> Int
processTuples xs ys =
  sum [ if b1 && b2 then a1 + a2 else a1 - a2
      | (a1,b1) <- xs
      | (a2,b2) <- ys ]

data Univ   = Univ { uniName :: String, uniID :: Int } deriving (Show, Eq)
data Student = Student
  { neptunID    :: Int
  , studentName :: String
  , uni         :: Univ
  , grades      :: [Int]
  } deriving Show
 
-- Rename a university for all its students (by uniID)
renameUniversity :: Univ -> String -> [Student] -> [Student]
renameUniversity target newName =
  map (\s ->
        if uniID (uni s) == uniID target
        then s { uni = (uni s) { uniName = newName } }
        else s)
 
-- Students with at least one grade > 90
outstandingStudents :: [Student] -> [String]
outstandingStudents sts =
  [ studentName s | s <- sts, any (>90) (grades s) ]

-- Simple binary tree
data Tree a = Node a (Tree a) (Tree a) | Leaf
  deriving Show
 
-- Swap left and right subtrees
swapSubTree :: Tree a -> Tree a
swapSubTree Leaf              = Leaf
swapSubTree (Node x l r) = Node x (swapSubTree r) (swapSubTree l)

data ExpressionTree a
  = Operand a
  | Operator String (ExpressionTree a) (ExpressionTree a)
  deriving Show
 
evaluate :: ExpressionTree String -> String
evaluate (Operand x)          = x
evaluate (Operator op l r) = "(" ++ evaluate l ++ op ++ evaluate r ++ ")"

data Color = Red | Blue | Yellow | Purple | Orange | Green
  deriving (Show, Eq)
 
combineColors :: Color -> Color -> Color
combineColors Red   Blue   = Purple
combineColors Blue  Red    = Purple
combineColors Red   Yellow = Orange
combineColors Yellow Red   = Orange
combineColors Blue  Yellow = Green
combineColors Yellow Blue  = Green
combineColors c1    c2
  | c1 == c2  = c1
  | otherwise = error "Unsupported combo"

data Team = Team { teamName :: String, teamID :: Int }
data Player = Player
  { playerID     :: Int
  , playerName   :: String
  , playerTeam   :: Team
  , playerScores :: [Int]
  }
 
-- Custom Show
instance Show Team where
  show t =
    "Team teamName " ++ show (teamName t) ++
    ", teamID "      ++ show (teamID t)
 
instance Show Player where
  show p =
    "Player ID " ++ show (playerID p) ++
    ", Name "    ++ playerName p      ++
    ", Team "    ++ show (playerTeam p) ++
    ", Scores "  ++ show (playerScores p)
 
-- Custom Eq: same total score, different team
instance Eq Player where
  p1 == p2 =
    sum (playerScores p1) == sum (playerScores p2) &&
    teamID (playerTeam p1) /= teamID (playerTeam p2)