motokiee

initials :: [(String, String)] -> [String]
initials xs = [pickup first last | (first, last) <- xs]
  where pickup first last = [head first] ++ ". " ++ [head last] ++ "."

motokiee

squareList :: [Int] -> [Int]
squareList xs = [ square' | x <- xs, let square' = x ^ 2]

motokiee

calcBmis :: [(Double, Double)] -> [Double]
calcBmis xs = [ bmi | (w,h) <- xs, let bmi = w / h ^ 2, bmi > 30.0]

motokiee

head' :: [a] -> a
head' [] = error "No Head"
head' (x:_) = x

head2' :: [a] -> a
head2' xs = case xs of [] -> error "No Head"
                       (x:_) -> x

describeList :: [a] -> String
describeList ls = "This list is" ++ case ls of [] -> " empty"

motokiee

replicate' :: Int -> a -> [a]
replicate' n x
   | n <= 0    = []
   | otherwise = x : (replicate' (n-1) x)

maximum' :: (Ord a) => [a] -> a
maximum' xs = case xs of [] -> error "maximum of empty list"
                         [x] -> x
                         (x:xs) -> max x (maximum' xs)

motokiee

replicate' :: Int -> a -> [a]
replicate' n x
   | n <= 0    = []
   | otherwise = x : (replicate' (n-1) x)

maximum' :: (Ord a) => [a] -> a
maximum' xs = case xs of [] -> error "maximum of empty list"
                         [x] -> x
                         (x:xs) -> max x (maximum' xs)

motokiee

zip' :: [a] ->[b] -> [(a,b)]
zip' _ [] = []
zip' [] _ = []
zip' (x:xs) (y:ys) = (x,y) : zip' xs ys


elem' :: (Eq a) => a -> [a] -> Bool
elem' a [] = False
elem' a (x:xs)
  | a == x    = True

motokiee

largestDivisible :: [Int] -> Bool
largestDivisible [] = False
largestDivisible (x:xs)
  | (x `mod` 3829) == 0 = True
  | otherwise = largestDivisible xs

motokiee

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
  let smallOrEqual = filter (<= x) xs
      larger = filter (> x) xs
  in quicksort smallOrEqual ++ [x] ++ quicksort larger

largestDivisible :: [Int] -> Bool
largestDivisible [] = False
largestDivisible (x:xs)

motokiee

chain :: Integer -> [Integer]
chain 1 = [1]
chain n
  | even n = n : chain (n `div` 2)
  | odd n  = n : chain (n * 3 + 1)

numLongChains :: Int
numLongChains = length (filter (\xs -> length xs > 15) (map chain [1..100]))

flip' :: (a -> b -> c) -> b -> a -> c