Question 1:

a)

a) e1 :: [Bool]
b) e2 :: (Int, Int, Int)
c) e3 x = (x,x,x)
d) e4 xs ys = xs or ys or xs ++ ys
e) e5 = \x -> (\y -> x+y)

b)

one :: a -> [a]

two :: a -> (a,a)

three :: [a] -> [a]

first :: a -> b -> a or a -> (b->a)

inc :: Num a => a -> a

c)

sum [] = 0

sum (n:ns) = n + sum ns

length [] = 0

length (x:xs) = 1 + length xs or length (_:xs) = 1 + length xs

reverse [] = []

reverse (x:xs) = reverse xs ++ [x]

map f [] = []

map f (x:xs) = f x : map f xs

replicate 0 x = []

replicate n x = x : replicate (n-1) x

d)

fac 3

= 3 * fac 2

= 3 * (2 * fac 1)

= 3 * (2 * (1 * fac 0))

= 3 * ( 2 * (1 *1))

=3 * (2 *1)

=3*2=6
Question 2:

Insert x [] = [x]

Insert x (y:ys) = if x <= y then

x : y : ys

else

Y : insert x ys

b)

insert 3 [1,2,4,5]

= 1 : insert 3 [2,4,5]

= 1 : 2 : insert 3 [4,5]

= 1 : 2 : 3 : [4,5]

= [1,2,3,4,5]

c)

isort [] = []

isort (x:xs) = insert x (isort xs)

d)

isort [3,2,1]

= insert 3 (isort [2,1])

= insert 3( insert 2 (isort [1]))

=insert 3( insert 2 (insert 1 (isort[])))

=insert 3 (insert 2 (insert 1 []))

=insert 3 (insert 2 [1])

=insert 3 [1,2]

=insert [1,2,3]

e) learn quicksort in all forms

smaller x xs = [a | a <- xs, a < x]

larger x xs = [a | a <- xs, a > x]

(smaller x xs = filter (<x) xs

larger x xs = filter (>x) xs)

f)

qsort [] = []

qsort (x:xs) =

qsort (smaller x xs)

++ [x] ++

qsort (larger x xs)

g)

qsort [3,2,4,1,5]

qsort [2,1] ++ [3] ++ qsort [4,5]

qsort [1] ++ [2] ++ qsort[] qsort[] ++ [4] ++ qsort [5]

[1] [] [] [5]