Fall 2008 Programming Project #3 CMSC 420
Hanan Samet
Program the following 11 functions in LISP. Make sure you test them thoroughly. Pay particular
attention to the efficiency of your solutions. Test data will be mailed to you. Turn in a run that
includes both a pretty printing of your functions and the execution of said functions on the test data.
1. Ordered lists of numbers (with duplicates):
(a) Write a function mergelists[x, y] which takes two ordered lists xand y, and makes
one ordered list from them, for example,
mergelists[’(2 3 4), ’(1 4)] = (1 2 3 4 4).
Your algorithm should run in time proportional to the number of elements in the two
lists.
(b) Using mergelists, write a function sortlist[l] which takes an unordered list land
makes an ordered list of it, for example,
sortlist[’(1 7 3 5 3)] = (1 3 3 5 7).
For an initial list of nelements, your algorithm should run in O(nlog n)time and not
O(n2)time.
(c) Write a predicate dup[l] which indicates if any atom occurs more than once in an
unordered list l, for example,
dup[’(1 3 5 3)] = t
The algorithm should be as efficient as sortlist. Make sure you compare numbers
with equal and not eq (eq will generally not return tfor two equal numbers if they are
sufficiently large.)
2. Lists of lists of numbers:
(a) Write a function countlists[l] which counts the number of top level lists in a list of
lists, for example,
countlists[’((1 2) (1 3) (1 4))] = 3.
(b) Lexical ordering on lists of numbers is a binary relation defined by:
lex-lt[x, y] = if null[x] or null[y] then null[x]
else if car[x]=car[y] then lex-lt[cdr[x], cdr[y]]
else car[x]<car[y]
Write a function duplist_of_lists[l] which returns tif any of the lists in a list of
lists lare identical. duplist_of_lists should be as efficient as sortlist.
(c) Given a list of numbers, there are several ways to obtain a list of all permutations of
these numbers. For example, the set of permutations of ’(1 2 3) is ’((1 2 3) (1
3 2) (2 1 3) (2 3 1) (3 1 2) (3 2 1)). Note that a list of nnumbers has n!
permutations. There are no duplications in the list and all sublists have the same number
of elements. One strategy, though not very efficient, is to take out each element, say a,
in turn from the list, permute the rest, and then attach ato the front of each permutation.
Write a function permute[l] to implement this method.
1
