UNIVERSITY THE OF WESTERN AUSTRALIA
EXAMINATION JUNE 2001 230.123
FOUNDATIONS OF COMPUTER SCIENCE 123
This paper contains: 12 questions 13 pages Time allowed: Reading time: TWO HOURS TEN MINUTES
All questions carry equal marks Candidates should attempt ALL questions
SURNAME: ____________________________________________________________ OTHER NAMES: ______________________________________________________ STUDENT NUMBER: _________________________________________________
All of the answers to the questions must be written in the spaces provided on this question sheet. No other paper will be accepted for the submission of answers. The white booklet is for rough work only. It will not be collected. In questions where you are given the specification of a function and asked to provide a definition, you do not need to copy the specification as part of your answer. An abstract from the Haskell Prelude is provided.
DO NOT WRITE IN THIS SPACE
1 1 2 3 2 3 4
June Examination
2 Computer Science 230.123 ___________________________________________________________________________ 1. Basic data types
A point can be represented as a pair of co-ordinates on a grid. type Point = (Float, Float) (i) Define a function distance with the following specification. distance :: Point -> Point -> Float -- distance p p' returns the distance between p and p' A circle can be represented as a Point, defining its centre, and a Float, defining its radius. type Centre = Point type Radius = Float type Circle = (Centre, Radius) (ii) Define a function inside with the following specification. inside :: Point -> Circle -> Bool -- inside p c returns True iff p is inside c (iii) One circle contains another circle if the second circle is entirely inside the first. Define a function contains with the following specification. contains :: Circle -> Circle -> Bool -- contains c c' returns True iff c entirely contains c'
distance (x, y) (x', y') = sqrt ((y - y') ^ 2 + (x - x') ^ 2)
inside p (q, r) = distance p q <= r
contains (p, r) (p', r') = distance p p' + r' <= r
contains (p, r) (p', r') = inside p' (p, r r')
___________________________________________________________________________
June Examination
3 Computer Science 230.123 ___________________________________________________________________________ 2. Reduction
Consider the functions removeBracketedBits and before. removeBracketedBits :: String -> String -- pre: the brackets in xs are balanced -- removeBracketedBits xs returns xs without its bracketed bits removeBracketedBits xs | null zs = xs | otherwise = removeBracketedBits (before '(' ys ++ tail zs) where ys = takeWhile (/= ')') xs zs = dropWhile (/= ')') xs before :: Eq a => a -> [a] -> [a] -- before x xs returns the elements of xs before -- the last occurrence of x -- e.g. before '(' "ab(cd(e(fg" = "ab(cd(e" List the sequence of applications of removeBracketedBits involved in the evaluation of the following expression, and the final result. removeBracketedBits "Wa((32)-)le(31(Eng))(!!)s"
"Wa((32)-)le(31(Eng))(!!)s"
"Wa(-)le(31(Eng))(!!)s"
"Wale(31(Eng))(!!)s"
"Wale(31)(!!)s"
"Wale(!!)s"
"Wales"
___________________________________________________________________________
June Examination
4 Computer Science 230.123 ___________________________________________________________________________ 3. (i) Polymorphism and type classes Give the names and types of two examples of each of the following. a. b. c. (ii) a monomorphic function, a parametrically polymorphic function, and an overloaded function.
Describe the two principal operational differences between a parametrically polymorphic function and an overloaded function.
(&&), (||) :: Bool -> Bool -> Bool
id :: a -> a length :: [a] -> Int
(+), (*) :: Num a => a -> a -> a
A pp function works for all instantiations of its type variables; an od function works only for some instantiations
A pp function does the same thing for every type; an od function does different things for different types
___________________________________________________________________________
June Examination
5 Computer Science 230.123 ___________________________________________________________________________ 4. Function types
Give the type of each function f1, ..., f4. Give a polymorphic or overloaded type where appropriate. (i) (ii) f1 x y = chr x == y f2 x y = [length y] ++ x
(iii) f3 x y = fst x > y (iv) f4 x y = y x : x
f1 :: Int -> Char -> Bool
f2 :: [Int] -> [a] -> [Int]
f3 :: Ord a => (a, b) -> a -> Bool
f4 :: [a] -> ([a] -> a) -> [a]
___________________________________________________________________________
June Examination
6 Computer Science 230.123 ___________________________________________________________________________ 5. (i) Arithmetic sequences and list comprehensions Use a list comprehension to define a function fives with the following specification. fives :: [Int] -- fives returns a list in increasing order which contains -- every integer between 1 and 100 which contains a 5 e.g. fives contains 5, 35 and 53 (plus some other values!). A square is a [[Int]], containing n lists each of length n. type Square = [[Int]] (ii) Use a list comprehension to define a function diags with the following specification. diags :: Int -> Square -- diags n returns a square of side n with each of -- the numbers 1 to 2n-1 running down a L-R diagonal e.g. diags 4 = [[4,5,6,7] ,[3,4,5,6] ,[2,3,4,5] ,[1,2,3,4]]
(iii) Use a list comprehension to define a function cycles with the following specification. cycles :: Int -> Square -- cycles n returns a square of side n with each of -- the numbers 1 to n running down one or two L-R diagonals e.g. cycles 4 = [[4,3,2,1] ,[3,4,3,2] ,[2,3,4,3] ,[1,2,3,4]]
fives = [k | k <- [1..100],
5
`elem` [k `mod` 10,k `div` 10]]
fives = [k | k <- [1..100], '5' `elem` show k]
diagonals n = [[k .. n + k - 1] | k <- [n, n - 1 .. 1]]
cycles n = [[n - k + 1..n] ++ [n - 1, n - 2..k] | k <- [1..n]]
___________________________________________________________________________
June Examination
7 Computer Science 230.123 ___________________________________________________________________________ 6. (i) Functions over lists Use the built-in list functions to define a function twolargest with the following specification. twolargest :: Ord a => [a] -> (a, a) -- pre: length xs >= 2 -- twolargest xs returns the two largest elements -- from xs (with the smaller one first) e.g. twolargest [5, 7, 2, 4, 5, 1, 4] = (5, 7). (ii) Use the built-in list functions to define a function third with the following specification. third :: [a] -> [a] -- pre: length xs `mod` 3 == 0 -- third xs returns the middle third of xs e.g. third [] = [], third [1 .. 3] = [2] and third [1 .. 9] = [4,5,6].
twolargest xs = (maximum (xs \\ [m]), m) where m = maximum xs
twolargest xs = (y2, y1) where y1 : y2 : ys = reverse (sort xs)
third xs = n take (drop n xs) where n = length xs `div` 3
___________________________________________________________________________
June Examination
8 Computer Science 230.123 ___________________________________________________________________________ 7. Recursion over natural numbers
Trusty Rent-a-Car has offices in Italy and Wales. When they first open for business, they have sixty cars at each location. Each subsequent month, they find that one half of the cars that start the month in Italy end it in Wales, and one third of the cars that start the month in Wales end it in Italy. (i) Use recursion over the natural numbers to define a function trusty with the following specification. trusty :: Int -> (Int, Int) -- pre: n >= 0 -- trusty n returns the number of Trusty's cars in -- Wales and Italy respectively at the end of the nth month e.g. trusty 1 = (70, 50). (ii) After how many months does the situation reach equilibrium?
(iii) How many cars are at each location at that time?
trusty 0 = (60, 60) trusty n = (w - w' + i', i - i' + w') where (w, i) = trusty (n - 1) w' i' = w `div` 3 = i `div` 2
(60, 60) ==> (70, 50) ==> (72, 48), i.e. two months
72 in Wales and 48 in Italy
___________________________________________________________________________
June Examination
9 Computer Science 230.123 ___________________________________________________________________________ 8. (i) Recursion over lists Use recursion over lists to define a function mul with the following specification. mul :: Int -> [Int] -> Int -- mul k xs returns the sum of multiplying -- every element on xs by k e.g. mul 4 [1 .. 3] = 4 * 1 + 4 * 2 + 4 * 3 = 24. (ii) The all-product of two lists is the sum of multiplying every number on the first list by every number on the second list. Use recursion over lists, and mul, to define a function ap with the following specification. ap :: [Int] -> [Int] -> Int -- ap xs ys returns the all-product of xs and ys e.g. ap [4 .. 5] [1 .. 3] = 4 * 1 + 4 * 2 + 4 * 3 + 5 * 1 + 5 * 2 + 5 * 3 = 54.
mul k []
= 0
mul k (x : xs) = k * x + mul k xs
ap []
ys = 0
ap (x : xs) ys = mul x ys + ap xs ys
___________________________________________________________________________
June Examination
10 Computer Science 230.123 ___________________________________________________________________________ 9. Mathematical induction
Consider the following recursive definitions. length :: [a] -> Int length [] = 0 length (x:xs) = 1 + length xs sum :: Num a => [a] -> a sum [] = 0 sum (x:xs) = x + sum xs Use induction to prove the following theorem. length (concat xss) = sum (map length xss) Justify each step in your proof. You may assume that length distributes over ++, i.e. that length (xs ++ ys) = length xs + length ys concat :: [[a]] -> [a] concat [] = [] concat (x:xs) = x ++ concat xs map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = f x : map f xs
length (concat []) = length [] = 0 = sum [] = sum (map length [])
concat length sum map
length (concat (x : xs)) = length (x ++ concat xs) = length x + length (concat xs) = length x + sum (map length xs) = sum (length x : map length xs) = sum (map length (x : xs))
concat length over ++ inductive hypothesis sum map
___________________________________________________________________________
June Examination
11 Computer Science 230.123 ___________________________________________________________________________ 1 0 . Infinite lists The built-in function iterate repeatedly applies a function to a value to generate an infinite list of results. iterate :: (a -> a) -> a -> [a] -- iterate f x returns an infinite list -- of nested applications of f to x iterate f x = x : iterate f (f x) (i) Give the first five values on the list returned by iterate (drop 2) [1 .. 5] (ii) Give an application of iterate that doesn't return an infinite list.
(iii) Use iterate to define a function remainder with the following specification. remainder :: Int -> Int -> Int -- pre: x >= 0 && y > 0 -- remainder x y returns x `mod` y e.g. remainder 14 3 = 2. (iv) Use iterate to define a function quotient with the following specification. quotient :: Int -> Int -> Int -- pre: x >= 0 &&...