 ## CS 334 Programming Languages Spring 2002 Assignment 1 Due Thursday, 2/14/02

I would like you to turn in paper and electronic versions of your programs. To turn in individual files, be sure you are in the directory containing the file and then type

```   turnin filename
```
where filename is the name of your file. It will then prompt you for the course. Please type 334, and your file will be deposited properly. You may turnin as many files as you like as long as they have different names. Please use names that indicate the assignment and problem number(s). Please make sure that your programs will run if we "use" them from within sml. Thus enclose problem numbers, etc. in (* ... *) so they will be treated as comments.

Please also turn in well-documented(!) print-outs of programs as well as the answers to non-programming questions. (Among other things, please make sure that identifier names are intelligible so that I can understand what each stands for in the programs.)

Problems to be turned in

1. Write a function int_to_string which converts an integer (positive or negative) to the string of its digits. Hints: It is easy to write int_to_string if you have a function non_neg_to_string, which converts a non-negative integer to a string. Similarly it is relatively easy to write non_neg_to_string given a function, digit_to_char. Here is a definition of digit_to_char:
`   fun digit_to_char (n:int) = chr (n + ord #"0");`
Use a let clause to hide the auxiliary functions.

1. Write the function zip to compute the Cartesian product of two lists of arbitrary length:
```   - zip [1,3,5,7] ["a","b","c","de"];
val it = [(1,"a"),(3,"b"),(5,"c"),(7,"de")]: (int * string) list
```
Note: If the vectors don't have the same length, you may decide how you would like the function to behave. If you don't specify any behavior at all you will get a warning from the compiler that you have not taken care of all possible patterns.

2. Write the inverse function, unzip, which behaves as follows:
```   - unzip [(1,"a"),(3,"b"),(5,"c"),(7,"de")];
val it = ([1,3,5,7], ["a","b","c","de"]): int list * string list
```
3. Write zip3, to zip three lists. Why can't you write a function zip_any that takes a list of any number of lists and zips them into tuples? From the first part of this question it should be pretty clear that for any fixed n, one can write a function zipn. The difficulty here is to write a single function that works for all n! I.e., can we write a single function zipn s.t. zipn [list1,list2,...,listk] returns a list of k-tuples no matter what k is?

2. Recursion is the only means of obtaining looping behavior in ML, but not all recursive programs take the same amount of time to run. Consider, for instance, the following function that raises a number to a power:
```   fun exp base power =
if power = 0 then 1 else base * (exp base (power-1));
```
There are more efficient means of exponentiation. First write an ML function that squares an integer, and then using this function, design an ML function fastexp which calculates (basepower) for any power >= 0 by the rule
```   base0 = 1
basepower = (base(power/2))2 if power is even
basepower = base * (base(power-1))    if power is odd
```
It is easy to blow this optimization and not save any multiplications. Prove the program you implemented is indeed faster than the original by comparing the number of multiplications that must be done for exponent m in the first and second algorithms. (Hint it is easiest to calculate the number of multiplications if the exponent, power, is of the form 2k for the second algorithm. Give the answer for exponents of this form and then try to give an upper bound for the others. Also recall that ML is call-by-value. That is, the argument to a function is evaluated before the call.)

3. Please write a function find with type ''a * ''a list -> int that takes a pair of an element and a list and returns the location of the first occurrence of the element in the list. For example,
```   find (7, [1,5,7,2])
```
would return 2. First write a definition for find where the element is guaranteed to be in the list. Now modify your definition so that it returns ~1 if the element is not in the list.

4. One can implement binary trees that only store values at the leaves using the datatype declaration
```    datatype 'a tree =
Leaf of 'a | InternalNode of ('a tree) * ('a tree)
```
1. Implement the function isBalanced which determines if a tree is balanced. A tree is balanced if the left and right subtrees are balanced and the height of the left and right subtrees differ by no more than one. You may find it helpful to define an auxiliary function that determines the height of a tree.

2. What is non-optimal about using a height function to answer part a? How could you change isBalanced to make it more efficient? You don't have to actually write the new function, just describe what you would need to change.

Back to: