CSC 153	Grinnell College	Spring, 2009

Computer Science Fundamentals

Recursion: The Basics

Goals

This lab introduces recursion −− a problem-solving technique in which procedures include one or more calls to the procedures themselves.

Steps for this Lab

Consider the following procedure.
```
(define longer-string
  (lambda (str1 str2)
    (if (< (string-length str1) (string-length str2))
        str2
        str1)))
```
1. Explain (in English) what this procedure does.
2. Test longer-string within the Scheme environment to illustrate how this procedure works in various circumstances.

Now consider the following recursive procedure longest-on-list that uses procedure longer-string.

(define longest-on-list
  (lambda (ls)
    (if (null? (cdr ls))
        (car ls)
        (longer-string (car ls)
                       (longest-on-list (cdr ls))))))

Test longest-on-list in the following cases:

(longest-on-list '("This" "is" "the" "forest" "primeval")) 
(longest-on-list '("Wherefore" "art" "thou" "Romeo"))
(longest-on-list '("To" "be" "or" "not" "to" "be"))
(longest-on-list '("foo"))
(longest-on-list '("keep" "it" "short" "and" "sweet"))
(longest-on-list '("you" "can" "see" "the" "top"))

Write a paragraph that describes how this procedure longest-string works.
Apply longest-on-list to the empty list. Explain why you get the result returned.

Consider the following recursive procedure power:
```
(define power
  (lambda (n k)
    (if (= k 1)
        n
        (* n (power n (- k 1))))))
```
1. Run power on several test cases that illustrate that this procedure performs as indicated by the pre- and post-conditions.
2. Write a paragraph to explain how power accomplishes its task.

With these examples as illustrations, the next four exercises ask you to write your own recursive procedures to solve a variety of problems.

Write a recursive procedure countdown that takes any non-negative integer start as its argument returns a list of all the positive integers less than or equal to start, in descending order:
```
(countdown 5) ===> (5 4 3 2 1)
(countdown 1) ===> (1)
(countdown 0) ===> ()
```

Write a more general version of list-of-zeroes: a procedure replicate that takes two arguments, size and item, and returns a list of size elements, each of which is item:

(replicate 6 'foo) ===> (foo foo foo foo foo foo)
(replicate 2 #f) ===> (#f #f)
(replicate 1 15) ===> (15)
(replicate 3 '(alpha beta)) ===> ((alpha beta) (alpha beta) (alpha beta))
(replicate 0 'help) ===> ()

Use the same problem-solving pattern illustrated in the reading for square-each-element to write a procedure double-each-element that takes a list of numbers and returns a list of their doubles:
```
(double-each-element '(3 -62 41.4 17/4)) ===> (6 -124 82.8 17/2)
(double-each-element '(0)) ===> (0)
(double-each-element '()) ===> ()
```
Write a procedure that computes the termial of any natural number number, that is, the result of adding together all of the natural numbers up to and including number. Here are some illustrative sample calls:
```
  (termial 7)   ===> 28 ; = 7 + 6 + 5 + 4 + 3 + 2 + 1 + 0
  (termial 1)   ===> 1  ; = 1 + 0
  (termial 0)   ===> 0
```

The next exercises involve one main procedure (e.g., tally-by-parity) that uses a second procedure (e.g., tally-helper) as a helper procedure.

Consider the following procedures from the reading for this lab:

(define tally-by-parity
   (lambda (ls)
      (tally-helper ls 0 0)))

(define tally-helper
   (lambda (ls number-of-odds number-of-evens)
      (cond ((null? ls) (list number-of-odds number-of-evens))
            ((odd? (car ls)) 
                   (tally-helper (cdr ls) (+ 1 number-of-odds) number-of-evens))
            (else  (tally-helper (cdr ls) number-of-odds (+ 1 number-of-evens))))))

Run tally-by-parity on the following examples to clarify what the procedure does.

(tally-by-parity '(2 3 5 7 11 13))
(tally-by-parity '(0 1 2 3 4 5 6))
(tally-by-parity '(-8 124 0 124))
(tally-by-parity '())

Describe (in words) what each of these procedures do.
Explain in a few sentences how this solution works. Include a discussion of what procedure tally-helper does. Be sure to explain the purpose of the three parameters ls, number-of-odds, and number-of-evens within tally-helper.

Use the idea of tally-by-parity and tally-helper to write a procedure called iota that takes any non-negative integer upper-bound as argument and returns a list of the non-negative integers strictly less than upper-bound, in ascending order:
```
(iota 6) ===> (0 1 2 3 4 5)
(iota 2) ===> (0 1)
(iota 1) ===> (0)
(iota 0) ===> ()
```

This document is available on the World Wide Web as

http://www.cs.grinnell.edu/~walker/courses/153.sp09/labs/lab-recursion.shtml

created 4 February 1997 by John David Stone last revised 25 January 2009 by Henry M. Walker
For more information, please contact Henry M. Walker at walker@cs.grinnell.edu.