-- 2013-12-09 -- Code-up of the exam from 2012-12 import Data.List import Test.QuickCheck import System.Random import Data.Maybe import System.Directory -- Consider the following function: chat 0 f (x:xs) = f x : xs chat _ _ [] = [] chat n f (x:xs) = x:chat (n-1) f xs chat' n f xs = [ if i == n then f v else v | (i,v) <- zip [0..] xs ] chat'' n f xs = case splitAt n xs of (ys,(xn:zs)) -> ys ++ f xn : zs (ys, []) -> ys -- You may assume that the first argument to -- chat will be a non-negative Int. -- (a) Give the type of chat (2p) chat :: Int -> (a -> a) -> [a] -> [a] {- (b) (3p) Give a definition for a function chat' which is equivalent to chat (under the assumption about the first argument), but which is defined using only the standard functions (as listed at the back). -} -------------------- {- (c) (2p) Define a quickCheck property that could be used to test the equivalence of chat and chat'. In your test you may use a specific function for the second parameter of chat. -} prop_chat n xs = let n' = abs n in chat n' not xs == chat' n' not xs ------------------- {- (d) (3p) A function findIn tries to find the earliest index at which its first argument can be found as a sublist of the second argument. It satisfies the following property: -} -- prop_findIn0 = findIn "Hell" "Hello" == Just 0 -- && findIn "ell" "Hello Jello" == Just 1 -- && findIn "Hell" "Helan" == Nothing {- With the help of the function isPrefixOf, give a definition of findIn, including its most general type, using a tail-recursive helper function. -} findIn needle haystack = findAt 0 haystack where findAt n [] = Nothing findAt n xs | needle `isPrefixOf` xs = Just n | otherwise = findAt (n+1) (tail xs) ------------------- {- (f) (3p) Define a quickCheck property which checks that whenever a list ys definitely contains xs as a sublist, then findIn xs ys will not give Nothing. Note: it is not necessary to create a new generator for lists to answer this question. -} prop_findIn xs ys zs = findIn ys (xs ++ ys ++ zs) /= Nothing where types = xs :: [Bool] -------------------------------------------------------- --- Question 2 type Journey = [Leg] type Place = String data Leg = Leg Place Mode Place deriving Show data Mode = Bus | Train | Flight deriving (Eq,Show) -- (a) (2 points) -- Complete the definition of the data type for a Journey. -- (b) (3 points) Define a function connected :: Journey -> Bool connected j = and [ a == b | ((Leg _ _ a), (Leg b _ _)) <- zip (init j) (tail j) ] -- no recursion. hint use: zip (init journey) (tail journey) -- (c) (4 points) -- Define, using recursion and none of the standard functions -- except for those in the Eq class, a function missingLegs :: Journey -> [(Place,Place)] missingLegs (Leg _ _ a : Leg b m c : legs) | a /= b = (a,b) : missingLegs (Leg b m c :legs) | otherwise = missingLegs (Leg b m c :legs) missingLegs _ = [] -- which computes the pairs of places that are not connected -- in the given Journey. This should satisfy: prop_missingLegs j = not(null j) ==> connected j == null (missingLegs j) -- (d) (4 points) Add appropriate instance declarations -- so that quickCheck can be run on prop_missingLegs. instance Arbitrary Leg where arbitrary = do let place = elements ["A","B","C"] from <- place to <- place mode <- elements [Bus,Train,Flight] return \$ Leg from mode to ------------------------------------------------------------- -- Question 3 -- The map of a simple text-based adventure game is modelled as data Map = Map PlaceName [(Dir,Map)] -- deriving Show data Dir = N | S | E | W deriving (Eq,Show) type PlaceName = String -- Example: hogwarts = Map "Castle" [(N,forest),(S,lake)] forest = Map "Forest" [(S,hogwarts)] lake = Map "Lake" [(N,hogwarts)] -- assume that (i) a direction appears at most once in a list -- and (ii) every distinct place in a map has a unique place name. -- (a) (4 points) Define a function travel :: Map -> [Dir] -> Maybe Map travel (Map h dirs) (d:ds) = case lookup d dirs of Just m -> travel m ds Nothing -> Nothing travel m [] = Just m -- travel hogwarts [N,S,S] Just lake -- travel hogwarts [N,E] == Nothing -- travel hogwarts [N,N] == Nothing -- Hint: the function lookup can be useful here. -- (b) (1 point) If we add deriving Show to Map, -- what happens when we try to print hogwarts? -- (c) (6 points) Make Map an instance of class Show -- in a way that allows maps to be -- displayed in the following way: {- > lake You are at the Lake. Go N to Castle Castle. Go N to Forest, Go S to Lake Forest. Go S to Castle > forest You are at the Forest. Go S to Castle Castle. Go N to Forest, Go S to Lake Lake. Go N to Castle Hints: the function intersperse could come in handy. As a wise man once said, to avoid going round in circles, it can be useful to remember where you've been. -} instance Show Map where show m = "You are at the " ++ showMap [] m showMap seenB4 (Map h ds) | h `elem` seenB4 = "" | otherwise = showHere ++ showDirs ++ "\n" ++ showOtherMaps where showHere = h ++ ". " showDirs = concat (intersperse ", " [ "Go " ++ show d ++ " to " ++ h' | (d,Map h' _) <- ds]) showOtherMaps = unlines [ showMap (h:seenB4) m | (_,m) <- ds] ----------------------------------------------------- -- Question 4 -- (a) Rewrite without do notation: backup f = do a <- readFile f let backup = f ++ ".bac" putStrLn \$ "Creating backup in " ++ backup writeFile backup a backup' f = readFile f >>= \a -> let backup = f ++ ".bac" in putStrLn ("Creating backup in " ++ backup) >> writeFile backup a -- (b) (2 points) -- For-loops found in typical imperative programs ... -- you should define a function for_ of type -- for_ :: [a] -> (a -> IO()) -> IO() {- which can represent simple for loops. For example a (psudocode) for loop for i = i to 10 { print i -} example = for_ [1..10] \$ \i -> print i for_ range c = sequence_ \$ map c range -- (c) (1 point) -- Give a definition for a more general function -- which collects the results of each iteration. -- for :: [a] -> (a -> IO b) -> IO [b] for range c = sequence \$ map c range -- (d) (2 points) {- Sometimes a large file (such as a video) needs to be split into a collection of smaller files. Suppose that these smaller files are named f.part1, f.part2,... This question is about joining them back together again to get the original file f. Use the function for to define the function -} join :: FilePath -> Int -> IO() {- such that join f i, when run, concatenates the contents of the i parts of file f together and writes them back into file f. You may assume that f and i are correctly specified. FilePath is equivalent to String. -} join f i = do parts <- for [1..i] \$ \j -> readFile (f ++ ".part" ++ show i) writeFile f (concat parts)