2. (18 points) Suppose that the following definitions are made (same as in Question 1):

Transcription

1 1. (18 points) Suppose that the following definitions are made: import Data.Char data Field = Pasture Char Lawn Integer Float Meadow String [Integer] gaze :: Integer -> Bool gaze m = odd m && m < 10 wonder :: (Char -> Bool) -> String -> Float wonder h (c:cs) h c = 6.0 otherwise = wonder h cs wonder h [] = plow :: Field -> Integer plow (Lawn s t) = s plow (Meadow cs (d:e:rest)) = e + plow (Pasture G ) plow _ = 70 Give the values of the following expressions. (a) (\ m -> [m+20]) 5 [25] (b) [3,5..12] [3,5,7,9,11] (c) unzip [(2,3),(9,1),(6,8)] ([2,9,6],[3,1,8]) (d) map gaze [6,3,7,11,2] [False,True,True,False,False] (e) [2,9,3]:[] [[2,9,3]] (f) plow (Lawn ) 21 (g) plow (Meadow "tractor" [5,9,2]) 79 (h) takewhile even [4,2,1,8,6,7,3] [4,2] (i) wonder islower "SYRacUsE" (18 points) Suppose that the following definitions are made (same as in Question 1):

2 import Data.Char data Field = Pasture Char Lawn Integer Float Meadow String [Integer] gaze :: Integer -> Bool gaze m = odd m && m < 10 wonder :: (Char -> Bool) -> String -> Float wonder h (c:cs) h c = 6.0 otherwise = wonder h cs wonder h [] = plow :: Field -> Integer plow (Lawn s t) = s plow (Meadow cs (d:e:rest)) = e + plow (Pasture G ) plow _ = 70 Give the types of the following expressions. (a) fst (plow,gaze) Field -> Integer (b) Pasture e Field (c) (\ (w,z) -> w + length z) (Int,[a]) -> Int (d) [ gaze k k <- [1..4] ] [Bool] (e) filter isalpha [] [Char] (f) Meadow String -> [Integer] -> Field (g) uncurry (&&) (Bool,Bool) -> Bool (h) zip "code" [b] -> [(Char,b)] (i) [toupper, tolower] [Char -> Char] 3. (12 points) For each of the following, fill in the blank with a pattern that gives the function the indicated behavior.

3 (a) one "apple" should return a and one [3,1,4,1,5,9] should return 3: (r:_) one = r (b) two [6,4,2,3,5] should return [2,4] and two "spring" should return "rp": (_:b:a:_) two = [a,b] (c) three (3, g,7) should return 4, and three ( m,true,5) should return 2: (_,_,c) three = c-3 (d) four [(10,20),(30,40)] should return 40, and four [(5,6),(7,8),(9,0)] should return 8: (_:(_,d):_) four = d 4. (6 points) Consider the following Haskell function: quibble :: Int -> [(Char,Int)] -> [Int] quibble j ps = [ m-j (d,m) <- ps, isalpha d ] Fill in the blanks below to write an equivalent function using map and filter: (\ (d,m) -> m-j) (\ (d,m) -> isalpha d) quibble j ps = map (filter ps)

4 5. (34 points) A small burrito shop offers a very limited menu: Drinks are available for $3.00 each. A large order of nachos costs $12.95, and a small order of nachos costs $8.50. There are three styles of burritos: chicken burritos, shrimp burritos, and bean burritos. The bean burritos costs $9.25 apiece; all other burritos cost $11.00 each. There are four fillings that can be added to burritos in any combination and any amount: rice, cheese, salsa, and onions. Each unit of filling adds $0.50 to the cost of a burrito, so (for example) adding two units of salsa and one unit of cheese increases a burrito s cost by $1.50. These menu options can be represented with the following Haskell types (note that none of the types belong to the Eq class, so you cannot use == or /= on values of these types): data Style = Chicken Shrimp Bean data Filling = Rice Cheese Salsa Onions data Size = Small Large data MenuItem = Drink Nachos Size Burrito Style [Filling] (a) (15 points) Write a Haskell function price :: MenuItem -> Float such that price item calculates the price (in dollars) of item. For example: *Main> price (Nachos Large) *Main> price (Burrito Bean [Rice, Onions, Rice, Cheese]) *Main> price (Burrito Shrimp []) 11.0 Sample solution #1: price Drink = 3.00 price (Nachos Large) = price (Nachos Small) = 8.50 price (Burrito Bean fs) = sum [ 0.5 _ <- fs] price (Burrito _ fs) = sum [ 0.5 _ <- fs] Sample solution #2:

5 price Drink = 3.00 price (Nachos Large) = price (Nachos Small) = 8.50 price (Burrito st fs) = cost st + sum [0.5 _ <- fs] cost :: Style -> Float cost Bean = 9.25 cost _ = (b) (12 points) Write a Haskell function cutcalories :: MenuItem -> MenuItem such that cutcalories item returns a menu item that is similar to item except that (i) large orders are replaced by small orders and (ii) any cheese is removed. For example: *Main> cutcalories (Nachos Large) Nachos Small *Main> cutcalories (Burrito Shrimp [Rice,Cheese,Salsa,Onions,Cheese]) Burrito Shrimp [Rice,Salsa,Onions] *Main> cutcalories Drink Drink Sample solution #1: cutcalories (Nachos _) = Nachos Small cutcalories Drink = Drink cutcalories (Burrito st fs) = Burrito st (filter notcheese fs) notcheese :: Filling -> Bool notcheese Cheese = False notcheese _ = True Sample solution #2: cutcalories (Nachos _) = Nachos Small cutcalories Drink = Drink cutcalories (Burrito st fs) = Burrito st (helper fs) helper :: [Filling] -> [Filling] helper [] = [] helper (Cheese:rest) = helper rest helper (item:rest) = item : helper rest (c) (7 points) Write a Haskell function withrice :: [MenuItem] -> Int such that withrice items computes the number of burritos in items that contain Rice. For example: *Main> withrice [Burrito Bean [Rice, Salsa, Rice], Burrito Shrimp []]

6 1 *Main> withrice [Drink, Nachos Small, Burrito Bean [Cheese]] 0 Sample solution #1: withrice items = sum [ 1 Burrito _ fs <- items, not (null [ 1 Rice <- fs])] Sample solution #2: withrice items = sum [ 1 Burrito _ fs <- items, hasrice :: [Filling] -> Bool hasrice [] = False hasrice (Rice:_) = True hasrice (_:rest) = hasrice rest hasrice fs] 6. (12 points) Write a Haskell function changefirst :: (a -> Bool) -> a -> [a] -> [a] such that changefirst p val xs returns a list that looks like xs except that the leftmost item in xs that satisfies predicate p is replaced by val. (If none of the elements of xs satisfy p, then xs is returned.) For example: *Main> changefirst even 33 [1,7,4,8,2] [1,7,33,8,2] *Main> changefirst even 33 [1,7,9,5] [1,7,9,5] *Main> changefirst islower! "Syracuse" "S!racuse" changefirst p val [] = [] changefirst p val (x:xs) p x = val:xs otherwise = x: changefirst p val xs