NullPointException

-- 定义函数，声明（参数a是Num/Ord类型，返回bool）+实现
biggerThanthree :: (Num a,Ord a) => a -> Bool
biggerThanthree a
     | a > 3 = True
     |otherwise =  False


capital :: String -> String
capital "" = "Empty string, whoops!"
capital all@(x:xs) = "The first letter of " ++ all ++ " is " ++ [x]


lucky' :: (Integral a) => a -> String
lucky' 7 = "LUCKY NUMBER SEVEN!"
lucky' x = "Sorry, you're out of luck, pal!"

-- 实现阶乘,递归
factorial :: (Integral a) => a -> a
factorial 0 = 1
factorial n = n * factorial (n - 1)

 
initials :: String -> String -> String
initials firstname lastname = [f]
    where (f:_) = firstname

-- 取list中的最大值
maximum' :: (Ord a) => [a] -> a
maximum' [] = error "maximum of empty list"
maximum' [x] = x
maximum' (x:xs)
	| x > maxTail = x
	| otherwise = maxTail
	where maxTail = maximum' xs

-- 多个重复数字组成的列表 
replicate' :: (Num i,Ord i) => i -> a ->[a]
replicate' n x
    | n <= 0 = []
		| otherwise = x:some
			where some = replicate' (n-1) x
-- replicate 4 3 输出[3,3,3,3]


-- List中取前n个数
take' :: (Num i,Ord i) => i ->[a] -> [a]
take' n []
	| n <= 0 = []
take' _ [] = []
take' n (x:xs) = x:take'(n-1) xs

-- 列表反转，递归
reverse' ::[a] ->[a]
reverse' [] = []
reverse' (x:xs) = reverse' xs ++ [x]

repeat' :: a -> [a]
repeat' x = x:repeat' x

-- 实现zip函数 输入两个列表，输出一个合并列表
zip' :: [a] -> [b] -> [(a,b)]
zip' [] _ = []
zip' _ [] = []
zip' (x:xs) (y:ys) = [(x,y)] ++ zip' xs ys
-- zip' [1,2,3,4] [2,2,2,2] 
-- 输出[(1,2),(2,2),(3,2),(4,2)]

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


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

-- 快速排序，简洁之美
quicksort' :: (Ord a) => [a] -> [a]
quicksort' [] = []
quicksort' (x:xs) = sm ++ [x] ++ bg
    where sm = quicksort'[a | a <- xs ,a <= x]
          bg = quicksort'[a | a <- xs ,a > x]

-- 调用两次函数 (a -> a)定义了函数
applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)
-- applyTwice (+3) 10
-- 输出: 16

-- zip两个列表然后函数映射上去
zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith' _ [] _ = []
zipWith' _ _ [] = []
zipWith' f (x:xs) (y:ys) = f x y : zipWith' f xs ys
-- zipWith' (+) [1,1,1] [2,2,2]
-- 输出: [3,3,3]


flip' :: (a -> b -> c) -> (b -> a -> c)
flip' f y x = f x y

-- 递归实现map
map' :: (a -> b) -> [a] -> [b]
map' _ [] = []
map' f (x:xs) = f x : map' f xs

-- 递归实现filter
filter' :: (a -> Bool) -> [a] -> [a]
filter' _ [] = []
filter' p (x:xs)
	| p x = x : filter' p xs
	| otherwise = filter' p xs


largestDivisible :: (Integral a) => a
largestDivisible = head[x | x <- [100000,99999.. ] , x `mod` 3829 ==0]

largestDivisible' :: (Integral a) => a
largestDivisible' = head (filter p [100000,99999..])
    where p x = x `mod` 3829 == 0

nini :: (Integral a) => a
nini = sum [x^2 | x <- [10000,9999..1], odd x]


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


sum' :: (Num a) => [a] -> a
sum' xs = foldl (\acc x -> acc + x) 0 xs


sum'' :: (Num a) => [a] -> a
sum'' = foldl1 (\acc x -> acc + x)


elem''' :: (Eq a) => a -> [a] -> Bool
elem''' y ys = foldl (\acc x -> if x == y then True else acc) False ys


maximum''' :: (Ord a) => [a] -> a
maximum''' = foldl1(\acc x -> if x > acc then x else acc )

reverse'' :: [a] -> [a]
reverse'' = foldl (\acc x -> x : acc) []