- Write functions that find the sum, mean
(mean = (sum xi) / n),
meansq (mean square = (sum xi2) / n),
variance, and
stddev (standard deviation) of a list of Integer.
sum should be int, while the others should be
double.
The variance is equal to the mean square minus the square of the mean
(= mean2).
The standard deviation is the square root of the variance.
Calculate these values for the following list of numbers:
(95 72 86 70 97 72 52 88 77 94 91 79 61 77 99 70 91)
- The sine function can be computed from its Taylor
series expansion:
1 3 5 7 9
x x x x x
sin(x) = -- - -- + -- - -- + -- - ...
1! 3! 5! 7! 9!
Write a function double sine(double x) to compute sine
using this series. You may not use the functions Math.pow
or factorial;
instead, write a tail-recursive auxiliary function to compute each
term of the series from the previous term and add it to the
sum. Stop after the 21st power of x. Hint: write down how
each term of the series differs from the previous term.
- Write a recursive function nthcdr(int n, Cons lst)
that returns lst after applying rest to it
n times. If there are fewer than n items
in lst, return null.
- Write a function elt(Cons lst, int n) that retrieves
the nth item in the list, the first item being numbered
0. This allows a list to be used like an array; how does
its Big O compare with array access?
- Write a function double interpolate(Cons lst, double x)
that will make lst, a list of Integer, appear to be a
continuous function by linearly interpolating for values of x.
Assume that the first element of the list is the value for x = 0,
the second element is the value for x = 1, etc. For cases where
i <= x < i+1, let delta = (x - i) and compute the value
f(x) = lst(i) + delta * (lst(i+1) - lst(i)) , where lst(i)
denotes the ith element of the list lst.
For example, suppose that lst = (0 30 56 78 96 ...).
The value for x = 3 is 78, and the value for x = 4 is 96.
interpolate(lst, 3.4) = 85.2, i.e., 78 + .4 * (96 - 78) .
Use your interpolate function to make the binomial
coefficient list for n = 12 look like a function.
What is the shape of this curve?
- Write a recursive function sumtr(Cons lst)
that adds all the numbers in lst.
The list lst may contain not only Integer, but
also sublists, recursively. Your function should sum the values
in the sublists also. You may assume that the only things in a list are
Integer and sublists; you can recognize a sublist because
consp will be true.
(sumtr '(1 (2 3) ((4 5) 6))) => 21
- Write a function subseq(Cons lst, int start, int end)
that returns a new list that is a sub-sequence of lst
beginning with the item numbered start and including
items through end - 1. We will assume that the input
lst contains enough elements.
(subseq '(0 1 2 3 4 5 6) 2 5) => (2 3 4)
- A filter is a function that allows desired elements
to pass through, while removing undesired elements.
Write a recursive function posfilter(Cons lst) that
returns a new list containing only the non-negative values in
lst, a list of Integer, in the same order as in
the original list.
(posfilter '(3 17 -2 0 -3 4 -5 12)) => (3 17 0 4 12)
- A predicate is a boolean function, which
tests its argument and returns true or false.
Write a recursive function subset(Predicate p, Cons lst)
that returns a new list containing only the values in
lst that satisfy the predicate p. In mathematical
notation, this would be written { x &isin lst | p(x) }, pronounced
the set of x in lst such that p(x).
We will
assume that p.pred(item) can be used to test an item.
The output list should be in the same order as the original list.
If we assume that the predicate myp tests for integers
> 3, then:
(subset 'myp '(3 17 -2 0 -3 4 -5 12)) => (17 4 12)
- A mapping relates an element of a set, called its
domain, to an element of another set, called its range.
Write a recursive function mapcar(Functor f, Cons lst)
that returns a new list containing the results of applying
f.fn(item) to each item in the list lst.
The output list should be in the same order as the original list.
If we assume that the functor myf adds 2 to an Integer,
(mapcar 'myf '(0 1 2 3 4 5 6)) => (2 3 4 5 6 7 8)
- Write a recursive function
Object some(Predicate p, Cons lst)
that returns the first item in lst that satisfies the
predicate p. In mathematical notation, this would be
written &exist x p(x), and pronounced there exists an x
such that p(x).
(some 'myp '(3 17 -2 0 -3 4 -5 12)) => 17
- Write a recursive function
boolean every(Predicate p, Cons lst)
that tests whether every item in lst satisfies the
predicate p. In mathematical notation, this would be
written &forall x p(x), and pronounced for all x, p(x).
(every 'myp '(3 17 -2 0 -3 4 -5 12)) => false