Haskell函数式编程基础习题(2)

一时失言乱红尘 2022-08-06 05:23 139阅读 0赞

--Exercise 4.17
    rangeProduct:: Int->Int -> Int
    rangeProduct a b 
    	| a > b = 1
    	| a == b = a 
    	| otherwise = a* b * ( rangeProduct (a+1) (b-1))
    fac :: Int -> Int
    fac a = rangeProduct 1  a
    
    --Exercise 4.16
    data Month = January  
    			|	February
    			|	March
    			|	April
    			|	May 
    			|	June
    			|	July
    			|	August
    			|	September
    			|	October
    			|	November
    			|	December
    			deriving(Eq,Show,Ord)
    month2Season :: Month -> Season
    month2Season month 
    	|  March <= month && month <= May= Spring
    	|  June <= month && month <= August = Summer
    	|  September <= month && month <= November = Automn
    month2Season _ = Winter
    --Exercise 4.15
    data Season  = Spring | Summer | Automn | Winter
    data Temp = Cold | Hot deriving (Eq,Show,Ord)
    getTemp :: Season -> Temp 
    getTemp Automn  = Hot
    getTemp Summer  = Hot
    getTemp _ = Cold
    
    --Exercise 4.14
    
    --Exercise 4.13
    
    --Exercise 4.12
    outcome :: Move -> Move -> Result
    outcome Rock  Scissors = Win
    outcome Scissors  Paper = Win
    outcome Paper  Rock = Win
    outcome Rock  Paper = Lose
    outcome Scissors  Rock = Lose
    outcome Paper  Scissors = Lose
    outcome _ _ = Draw
    
    --Exercise 4.11
    data Result = Win | Lose | Draw
    data Move = Rock | Paper | Scissors
    
    
    --Exercise 4.10
    
    --Exercise 4.10
    
    --Exercise 4.9
    		
    --Exercise 4.8
    triArea :: Float -> Float -> Float -> Float 
    triArea a b c
    	| possible = sqrt (s*(s-a)*(s-b)*(s-c))
    	| otherwise = 0.0
    	where 
    		s = (a+b+c)/2
    		possible = maxInt  < a+b+c - maxInt
    			where maxInt = max a $ max b c 
    
    --Exercise 4.7
    
    --Exercise 4.6
    
    --Exercise 4.5
    
    --Exercise 4.4
    howManyofFourEqual :: Int -> Int -> Int -> Int -> Int
    howManyofFourEqual a b c d =myEqualCount all
    							where all = [a,b,c,d]
     
    myEqualCount :: [Int] -> Int
    myEqualCount [] = 0
    myEqualCount t@(x:xs) =  (myGroupCount $ mygroup x t) + (myEqualCount $ listRemoveItem x t)
     
     
    listRemoveItem :: Int -> [Int] -> [Int]
    listRemoveItem a [] = []
    listRemoveItem a (x:xs) 
    	| a == x  = listRemoveItem a xs
    	| otherwise = x: listRemoveItem a xs
    
    myGroupCount :: [Int]-> Int
    myGroupCount [] = 0
    myGroupCount xs 
    	| length xs ==1 = 0
    	| otherwise = length xs
    	
    mygroup :: Int -> [Int] -> [Int]
    mygroup _ [] = []
    mygroup a (x:xs) 
    	| a == x = x : mygroup a xs
    	| otherwise = mygroup a xs
    
    --Exercise 4.3
    howManyEqual :: Int -> Int -> Int -> Int 
    howManyEqual a b c 
    	| myEqual a b && myEqual b c && myEqual a b = 3
    	| myEqual a b || myEqual b c || myEqual a b = 2
    	| otherwise =0
    
    myEqual :: Int -> Int -> Bool
    myEqual a b 
    	| a == b = True
    	| otherwise = False
    
    
    --Exercise 4.2
    between :: Int -> Int -> Int -> Bool
    between a b c 
    	| weakAscendingOrder a b c && (a /= b) && b /= c = True
    	| otherwise  = False
    
    weakAscendingOrder :: Int -> Int -> Int -> Bool
    weakAscendingOrder a b c 
    	| a <=b && b <=c = True
    	| otherwise = False
    
    --Exercise 4.1
    maxFour :: Int -> Int -> Int -> Int -> Int
    maxFour a b c d  = max a $ maxThree b c d
    
    maxThree :: Int -> Int ->Int -> Int 
    maxThree a b c = max a $ max b c
    
    --Exercise 3.27
    
    --Exercise 3.26
    
    mymax :: Int -> Int -> Int
    mymax a b 
    	| a > b = a
    	| otherwise = b