Project Description

Below are a set of Scheme functions that you are required to write for this project.  In general, you are not permitted to make assumptions about the arguments to each function other than the assumptions listed in the description of each function. For example, unless explicitly stated, you may not assume that all lists will be simple — a simple list is one with no sublists.

Make sure that your code works in Racket with the Advanced Student language level selected. Beyond that, we're also staying within an even more restricted subset of Scheme. You may only use the following predefined Scheme functions or constructs in your solution:

 

   define  lambda  cond  else  empty  empty?  first  rest  cons  list

   list?  =  equal?  and  or  not  +  -  *  /  <  <=  >  >=

 

Some of the functions below cannot be written easily without other "helper" functions. Turn in all of your helper functions along with the ones you are to write. You may reuse helper functions in more than one of your solutions if you'd like, though it isn't required. Similarly, you may call your solution to one of your functions in your solution to another.

 

The Advanced Student language level in DrScheme provides two equivalent ways of describing a list: using the list construct or a short-hand version consisting only of the lists elements surrounded by parentheses. For example, a list containing the numbers 1, 2, 3, 4, and 5 can be written in one of two ways:

 

    (list 1 2 3 4 5)

'(1 2 3 4 5)

 

These two notations can be a little confusing, because they sometimes require quoting in different places. For example, a list of symbols x, y, and z would look like this in each of the supported styles:

 

  (list 'x 'y 'z)

'(x y z)

 

For your work, either of these styles is fine when writing your functions. When using the Advanced Student language level, as we will be in this project, the list construct is used to describe lists returned as output.

 

Here are the six functions you're being asked to write. Each includes a brief set of examples that shows what its output should be in a few cases; note that these examples are not intended to be a complete set of tests for each function, so you may want to develop a few extra examples. (Remember to pay special attention to the base case for each function, which is not always listed in the examples, but whose answer you should be able to deduce from the description of the problem.)

 

(fourth-element L)
The fourth-element function takes a list L and returns its fourth element. Of course, not all lists have four or more elements; if L is a list that doesn't, the empty list should be returned. L is not necessarily simple, but you shouldn't handle sublists differently from other elements (i.e., if the fourth element is a sublist, return the whole sublist).

Examples:

   

    (fourth-element '(a b c d e))                      => d

    (fourth-element '(x (y z) w h j))                  => h

    (fourth-element '((a b) (c d) (e f) (g h) (i j)))  => (list 'g 'h)   or  ‘(g h)

(fourth-element '(a b c))                          => empty

 

(list-length L)
The list-length function takes a list L and returns the number of elements in the list.

Examples:

  

    (list-length '(a b c))           => 3

 (list-length '(a (b c) d e f))   => 5

 

(count-matches S L)
The count-matches function takes a symbol S and a simple list L of symbols and returns the number of times that S occurs in L.

Examples:

   

    (count-matches 'f '(a b c d e f g))   => 1

    (count-matches 'b '(a b a b a b a))   => 3

 (count-matches 'x '(a b c))           => 0

 

(my-append L1 L2)
The my-append function takes two lists, L1 and L2, and returns the concatenation of L1 and L2. ("Concatenation" means to stick one on the end of the other.) Note that concatenation is not the same thing as what "cons" does to two lists.

Examples:

   

    (my-append '(a b) '(c d))   => (list 'a 'b 'c 'd)

    (my-append '() '(a b))      => (list 'a 'b)

 (my-append '(a b) '())      => (list 'a 'b)

 

(is-increasing? L)
The is-increasing? function takes a simple list L of numbers and returns true if the numbers in the list are increasing as you read them from beginning to end, and false if they aren't. We'll define "increasing" according to the mathemtical definition of the word, where the numbers are increasing so long as they never decrease. (This is as opposed to what you might call "strictly increasing," where every number has to be bigger than the previous one.) As special cases, we'll consider one-element and empty lists to be increasing.

Examples:

   

    (is-increasing? '(1 2 3))          => true

    (is-increasing? '(3 2 1))          => false

    (is-increasing? '(1 2 2 3 4 4 5))  => true

    (is-increasing? '(1))              => true

 (is-increasing? '())               => true

 

(remove-duplicates L)
The remove-duplicates function takes a simple list L and returns a new list with all of the duplicate objects in L removed.

Examples:

   

    (remove-duplicates '(1 2 3))      => (list 1 2 3)

    (remove-duplicates '(1 2 1 4))    => (list 2 1 4)  -or-  (list 1 2 4)

 (remove-duplicates '(3 3 3 3 3))  => (list 3)