15-212-X : Homework Assignment 3

Due Wed Oct 8, 2:00pm (electronically); papers at recitation.

Maximum Points: 100 (+20 extra credit)

Guidelines

Strive for elegance in your code! Not every program which runs deserves full credit. Make sure to state invariants in comments which are sometimes implicit in the informal presentation of an exercise. If auxiliary functions are required, describe concisely what they implement. Do not reinvent wheels and try to make your functions small and easy to understand. Use tasteful layout and avoid longwinded and contorted code. None of the problems requires more than a few lines of SML code.
Make sure that your file compiles and runs. A program which doesn't run will not get full credit and is likely to incur a heavy penalty.
Homeworks must be all your own work.
Late homeworks will be accepted only until start lecture on Thursday, with a 25% penalty.
If you have any questions about the assignment, contact Frank Pfenning at fp@andrew.cmu.edu or use cmu.andrew.academic.15-212-X.discuss.

Please include needed auxiliary declarations from the ML files in /afs/andrew/cmu.edu/scs/cs/15-212-X/assignments/ass3/ in your solution file, so it compiles as is. Points will be deducted if your file does not compile by itself.

Problem 1: Dictionaries (35 points)

The company DataSoft decided recently to purchase CMU's dictionary package promising fast and easy access to their client records. The contract requires CMU to extend the signature of their dictionary package by a delete function, and a few other functions.

signature DICT =
sig
  type key = int * int
  type 'a entry = key * 'a

  type 'a dict

  val empty : 'a dict
  val lookup : 'a dict -> key -> 'a option
  val insert : 'a dict * 'a entry -> 'a dict
  val delete : 'a dict * key -> 'a dict

  val map       : 'a dict -> ('a -> 'b) -> 'b dict
  val fold      : 'a dict -> ('a * 'b * 'b -> 'b) -> 'b -> b'
  val exists    : 'a dict -> ('a entry -> bool) -> bool
end;  (* signature DICT *)

There is a partial implemenation of a structure BinarySearchTree with this signature in the file dict.sml. Plese extend this structure according to the following specifications.

Question 1.1 (5 points)

A call map d f should go through the whole dictionary d and apply the function f to every entry, creating a new dictionary. Write the function map.

Question 1.2 (10 points)

The function fold d f init should go through the binary tree d and return init if it encounters a leaf. For every other node in the tree it should return f(datum,vLeft,vRight) where datum is the datum of the node, and vLeft is the result of applying fold on the left subtree, vRight is the result of applying fold on the right subtree. Write the function fold.

Question 1.3 (5 points)

A call exists d p should return true if there is an entry in the database satisfying the predicate p, false otherwise. Write the function exists.

Question 1.4 (15 points)

A call delete (d, k) should return a dictionary d' in which a possible entry with key k has been removed. If there is no such entry, d' should be d. Make sure the invariant on binary search trees is preserved under this operation.

Problem 2: The PEG game (35 points)

Another company is interested in purchasing CMU's dictionary package: GAMESoft intends to implement the PEG solitaire game. The PEG solitaire game is best described as follows: A PEG board contains 15 holes, shaped in form of a triangle. Every hole can be addressed by a pair of coordinates.

Initially 14 of the holes are filled with pegs . That means there is one empty hole somewhere on the board. In our example it is (1,2), which is the standard initial board.

During the game it is possible to take a peg, jump over a peg into an empty hole. The peg that was jumped over is then removed from the board. It is important that

the jumping peg jumps 2 fields,
the destination is an empty hole,
and there is a peg inbetween.

It should be clear that pegs might jump into six different directions.

The goal of the peg solitaire game is to jump pegs in such a way that only one peg remains on the board eventually.

Initially GAMESoft was only interested in purchasing CMU's dictionary package. But because of its nice implementation, GAMESoft decided to ask you for programming help. Here is what the company has already done using the signature DICT from above:

structure Dict :> DICT = BinarySearchTree;

datatype square = Peg | Hole;
type board = square Dict.dict;

structure Dir =
struct
  datatype direction =
    East | NorthEast | NorthWest | West | SouthWest | SouthEast

  fun increment (East) = (1,0)
    | increment (NorthEast) = (0,1)
    | increment (NorthWest) = (~1,1)
    | increment (West) = (~1,0)
    | increment (SouthWest) = (0,~1)
    | increment (SouthEast) = (1,~1)

  fun exists p = p East orelse p NorthEast orelse p NorthWest
                 orelse p West orelse p SouthWest orelse p SouthEast
end;

fun initialize (i,j) b = next (i,j) (Dict.insert (b,((i,j),Peg)))
and next (0,0) b = b
  | next (i,0) b = initialize (i-1,5-i) b
  | next (i,j) b = initialize (i,j-1) b;

val fullBoard = initialize (4,0) (Dict.empty);

See the file solitaire.sml for this code.

Question 2.1 (25 points)

Write a function solve : int -> board -> bool, where solve n b returns true if there is a possibility to make n consecutive moves otherwise false. That means if solve 13 applied to the initial board returns true then there is a way to remove all but one peg. Is your implementation efficient enough to determine that there cannot be 14 consecutive moves?

Question 2.2 (10 points)

Define a type solution containing enough information so that a sequence of moves can easily be replayed from it. Generalize the function from Question 2.1 to a function

findSolution : int -> board -> solution option

which returns the first found solution or NONE for the given number of moves n. Check the solution returned by findSolution 13 on the standard initial board.

Problem 3: Regular expressions (30 points + 20 extra credit)

In class five different operators have been introduced to describe regular expressions R:

Characters a
Concatentation r₁ r₂
The empty string One
Alternative r₁ + r₂
Empty set Zero
Repetition r^*

This has been implemented as the following datatype.

datatype regexp =
    Char of char
  | Times of regexp * regexp
  | One
  | Plus of regexp * regexp
  | Zero
  | Star of regexp;

From time to time it is helpful to have some more constructs available to form regular expressions, such as

A wildcard symbol _ which accepts any character
L(_) = {a | a is a character in the alphabet}
The constructor must be called Underscore.
Intersection r₁ & r₂ which accepts a string only if it is contained in r₁ and simultaneously in r₂.
L(r₁ & r₂) = {s | s in L(r₁) and s in L(r₂)}
The constructor must be called And.
A wildcard T which matches any string.
L(T) = {s | s is a string over the alphabet}
The constructor must be called Top.
Negation ~ r which contains every string which is not contained in r.
L(~ r) = {s | s not in r}
The constructor must be called Not.

The regular expression matcher accept is available in the file regexp.sml and should be extended to deal with these new constructors. Remind yourself of the specification of the acc function and make sure your new cases fit this specification. You should also generate some test data to validate your implementation. Note that for the purposes of our implementation, the alphabet is simply any ML value of type char.

Question 3.1 (5 points)

Implement the case for the one-character wildcard _.

Question 3.2 (15 points)

Implement the case for intersection r₁ & r₂.

Question 3.3 (10 points)

Implement the case for T.

Question 3.4 (Extra credit, 10 points)

Prove the correctness of the case for intersection in your implementation, following the pattern in the handout.

Question 3.5 (Extra credit, 10 points)

Implement the case for Negation.

Handin instructions

Put your SML code into a single file named ass3.sml in your ass3 directory. All of your definitions should be in this one file. Please keep a backup for your records. Your handin directory for this assignment is

/afs/andrew/scs/cs/15-212-X/studentdir/<your andrew id>/ass3/