Gonville & Caius College
Cambridge CB2 1TA

Supervision schedule

Here is a schedule of work for supervisions with Graham Titmus.

Your solutions should be handed in to the main Porters' Lodge at Caius College by noon on the day preceding the supervision. The supervisions will be held in my room at Caius, P11 Tree Court, as follows:

Tuesday 14:00
Wednesday 14:00

Michaelmas Term 2002

Week 1 (due w/b 14-Oct-2001)

Questions 1-12 from Goldschlager & Lister Chapter 2.

Week 2 (due w/b 21-Oct-2002)

Exercises 1.1 to 2.3 from the Lecture notes.

A number q is rational if q = a/b, where a and b are integers with b not 0. Construct a program to perform the usual arithmetic operation on rational numbers: addition, subtraction, multiplication, division and equality. The program should also contain a function to convert a rational number to a suitable text representation.

Tackle this by doing the following

  1. Analyse the problem and identify necessary data and functions, specify the types of the functions you will write.
  2. Program to the above specification.
  3. Test the program - test examples should aim to cover every line of code!

Hint: you might need to implement Euclid's algorithm for the greatest common divisor to use in the above.

Week 3 (due w/b 28-Oct-2002)

Do exercices from chapters 3 to 5 from the lecture notes.

In addition consider the following problem, known as the Knight's tour.

Can a knight moves to all the places on a chess board but only landing on each one once?

Each time the knight has a choice of moves:-

To start work on this problem do the following work only.

  1. Decide upon a representation for the chessboard and write a function to generate a board with no moves yet taken place on it. Name the function makeboard which is of type
    int -> board_type
    where board_type is up to you. The int part is the size of the board which is square.
  2. Write a function which when given a poistion of a knight and a board will return a list of the possible moves. The functions should be called generateMoves and will be of type
    (int * int) * board_type -> (int * int) list
    where int * int is a coordinate on the board. [] being returned when no moves exist.
  3. Test these functions by placing the knight in various positions and checking that you get back the correct result. State the criteria you use to choose test values.
Remember for this part to design, code and test your solution and document each part clearly.

Week 4 (due w/b 4-Nov-2002)

Study the following ML function definitions and answer the questions below:

fun prefix [ ]  [ ] = [ ]
  | prefix (x::xs) (y::ys) = (x::y)::prefix xs ys;

fun sep [ ] = [[ ],[ ]]
  | sep [x] = [[x],[ ]]
  | sep (x::y::rest) = prefix [x,y]  (sep rest);

fun merge [[ ],y] = y : int list
  | merge [x,[ ]] = x
  | merge [x::xs, y::ys] =
           if x < y then x :: merge [xs, y::ys]
                  else y :: merge [x::xs, ys];
  1. Deduce the ML type of the function prefix showing your method of deduction in detail. Verify by evaluating the result of the call prefix [1,2,3] [[4],[5],[6]];
  2. Give a correctly-typed call to prefix that will generate an exception when evaluated. Explain why this is possible despite the type checking by the compiler.
  3. What values do sep[l,2,3,4,5,6,7,8] and sep[1,2,3,4,5,6,7] yield?
  4. Deduce the ML type of merge, showing your working in detail, and explain why the omision of `: int list' would lead to an error.

Next do exercises from chaper 6 up to and including chapter 9.

Finally, consider the problem of getting out of a maze. Below is a schematic of the maze at Hampton Court.

  1. What sort of data structure could you use to represent this?
  2. Label up the maze as necessary and construct your representation.
  3. Design but do not code your algorithm for escaping from the maze.

Week 5 (due w/b 11-Nov-2002)

Do exercises from chapters 10 to 12 from the lecture notes

Code and test the maze program that we considered last week. Document your design, your code and your test data.

Write a shortest path finding program to find the distance from the front (1) to the back (18) of the Guildhall. As before you should split this into three parts, design, code and test making each stage visible. Identify how you needed to extedn the maze program to solve this problem.

You can either start from the map of Cambridge and measure the points yourself or use this list:-

val roads = [(1,2,0.4, 1),(2,1,1.5,1),(2,3,1.0,1),
where each entry is as follows
    (node1, node2, distance, 1=one way|2=bidirectional)
Aim to clearly document how your code works. Then try to add a new link (8,6,3.5,2) from the matrix of connections and see what difference it makes to the distance.

Week 6 (due w/b 18-Nov-2002)

Binary (or higher) trees are a common data structure. Using the datatype:-
datatype 'a tree = leaf | node of 'a tree * 'a * 'a tree;
Construct the following functions
  1. InsertItem: (('a * 'a) -> boolean) * 'a * 'a tree) -> 'a tree
    given an item returns a new tree with the item inserted. Make sure your function obeys the type rule! What is the ('a * 'a) -> boolean for?
  2. BuildTree: ('a list, ('a * 'a) -> boolean)) -> 'a tree
    given alist of items returns a tree with the items in order.
  3. BuildBalancedTree: ('a list, ('a * 'a) -> boolean)) -> 'a tree
    given a list of items returns a tree with the items in order and also the tree is a balanced as possible. To do this you need to think about how you can rewrite a tree to preserve order but have a different arrangment of branches. Look at the section on Rotations under Red-Black trees in Cormen Introduction to Algroithms (p266) for a hint of how to proceed.
  4. You could consider building curried versions of these functions and examine the types you get back when you hand them a comparison function.
  5. Fringe: ('a tree) -> 'a list
    given a tree returns the items in order.
  6. TreesEqual ('a tree * 'a tree) -> boolean
    given two trees returns whether they are equal or not. You can do this by calling Fringe on each list and then comparing the two lists. However, try to do it by only examining as much of the tree as is necessary by creating a lazy fringe function
Remember to describe and test your algorithms as well as coding. Include printo ut to demonstrate that your code functions correctly and parts 3 and 5 discuss how you chose your test data.

Make the maze and City streets problem into Lazy List versions.

Week 7 (due w/b 25-Nov-2002)

Try to finish the Knight's tour problem and find a solution. You should use a list of (x,y) 2-tuples to represent the board. You need to think about how to handle the backtracking and avoid going down the same solution path twice. You should test your algorithm on a smaller board.

I want a description of how you designed your solution. Don't look for short-cuts, do a strightforward exhaustive search and return the first solution. Try it out on smaller custom boards for which a solution does exist and make sure it finds them.

The following ML declaration introduces a data type that can be used to represent a potentially infinite arrangement of cells at positions with integer coordinates in the first quadrant of the x - y plane:
datatype A = Z
           | Cell of int ref * A ref * A ref;
Each cell contains an integer value and pointers to the cells immediately to its right and above itself. These three components are all mutable so that the arrangement of the cells and the integers they contain can change during use. The constructor Z can be used in an A ref to allow a cluster to have a boundary rather than continuing through unbounded chains of cells.

Define a function mkrow(n) of type int->A that will return a row of length n + 1 cells initialised with zeros. For instance:

mkrow(1) = Cell(ref 0, ref(Cell(ref 0, ref Z, ref Z)), ref Z)

Define a function zip (rowl, row2) of type A*A->A that will return row1 with row2 joined above it. This function is entitled to change some of the ref A pointers in rowl. For example

val root = zip(mkrow(3), mkrow(2));
would give root a value representing the following arrangement.
                     0 ----> 0 ----> 0
                     ^       ^       ^
                     |       |       |
                     |       |       |
              root : 0 ----> 0 ----> 0 ---> 0

Next define a function mkarr (m, n) of type (int* int) ->A that will return a value representing a rectangular array of n + 1 rows each ofwhich are of length m + 1 in which each cell is initialised to zero.

Paths originating from the bottom leftmost cell (which will be referred to by the variable root) are represented by values of the type dir list where dir is declared as follows:

datatype dir = Right | Up;
Finally define a function inc-path-cells of type A-> dir list -> unit that will increment the integers in all the cells that lie on a specified path within a given collection of cells. For instance after root had been set up as above, the two calls
inc-path-cells root [Right, Up, Right];
inc-path-cells root [Right, Right, Right];
would leave root representing the following arrangement:
                     0 ----> 1 ----> 1
                     ^       ^       ^
                     |       |       |
                     |       |       |
              root : 2 ----> 2 ----> 1 ---> 1
You may assume that the path does not try to reach cells outside the given arrangement.

Week 8 PP&E(due w/b 26-Nov-2001)

Is there such a thing as a "Right to Privacy"? What are "rights" in the context of ethics? Discuss the philosophical basis of privacy in relation to the Data Protection Act (1998).

Consider whether Computer Scientists are Professionals. Look at the code of conduct of one of the professional bodies (ACM or BCS) and comment on its policies in the light of your discussion of the first question.

You may find the following site useful - Ethics and Intellectual Property Resources on the Web.

University of Cambridge Computer Laboratory William Gates Building J J Thomson Avenue Cambridge CB3 0FD England E-mail: Graham.Titmus@cl.cam.ac.uk Telephone: +44 1223 334620 Facsimile: +44 1223 334678