Fundamentals of Computer Science 1 (CS151 2003S)
[Skip to Body]
Primary:
[Front Door]
[Current]
[Glance]

[EC]
[Honesty]
[Instructions]
[Links]
[Search]
[Syllabus]
Groupings:
[EBoards]
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Lab Writeups]
[Outlines]
[Project]
[Readings]
[Reference]
ECA:
[About]
[Grades]
[Quizzes]
[Submit Work]
[Change Password]
[Reset Password]
Misc:
[Scheme Reference]
[Scheme Report]
[CS151 2003S Gum]
[CS151 2002F]
[CS151 History]
[SamR]
Summary: In this laboratory, you will begin your experimentations with recursion by (1) considering some predefined recursive procedures and (2) designing your own recursive procedures.
a. Reflect on the key aspects of recursion.
b. Start DrScheme.
Here are the two versions of sum
as given in
the reading on recursion.
;;; Procedure: ;;; sum ;;; newsum ;;; Parameters: ;;; numbers, a list of numbers. ;;; Purpose: ;;; Find the sum of the elements of a given list of numbers ;;; Produces: ;;; total, a number. ;;; Preconditions: ;;; All the elements of numbers must be numbers. ;;; Postcondition: ;;; total is the result of adding together all of the elements of ls. ;;; total is a number. ;;; If all the values in numbers are exact, total is exact. ;;; If any values in numbers are inexact, total is inexact. (define sum (lambda (numbers) (if (null? numbers) 0 (+ (car numbers) (sum (cdr numbers)))))) (define newsum (lambda (numbers) (newsumhelper 0 numbers))) ;;; Procedure: ;;; newsumhelper ;;; Parameters: ;;; sumsofar, a number. ;;; remaining, a list of numbers. ;;; Purpose: ;;; Add sumsofar to the sum of the elements of a given list of numbers ;;; Produces: ;;; total, a number. ;;; Preconditions: ;;; All the elements of remaining must be numbers. ;;; sumsofar must be a number. ;;; Postcondition: ;;; total is the result of adding together sumsofar and all of the ;;; elements of remaining. ;;; total is a number. ;;; If both sumsofar and all the values in remaining are exact, ;;; total is exact. ;;; If either sumsofar or any values in remaining are inexact, ;;; total is inexact. (define newsumhelper (lambda (sumsofar remaining) (if (null? remaining) sumsofar (newsumhelper (+ sumsofar (car remaining)) (cdr remaining)))))
a. Verify experimentally that they work.
b. Which version do you prefer? Why?
c. Here's an alternative definition of newsum
.
(define newersum (lambda (numbers) (newsumhelper (car numbers) (cdr numbers))))
Is it superior or inferior to the previous definition? Why?
Here is a variant of the greatestoflist
procedure givin in
the reading on recursion.
;;; Procedures: ;;; greatestoflist ;;; Parameters: ;;; numbers, a list of real numbers. ;;; Purpose: ;;; Find the greatest element of a given list of real numbers ;;; Produces: ;;; greatest, a real number. ;;; Preconditions: ;;; numbers is not empty. ;;; All the values in numbers are real numbers. That is, numbers ;;; contains only numbers, and none of those numbers are complex. ;;; Postconditions: ;;; greatest is an element of numbers (and, by implication, is real). ;;; greatest is greater than or equal to every element of numbers. (define greatestoflist (lambda (numbers) ; If the list has only one element (if (null? (cdr numbers)) ; Use that one element (car numbers) ; Otherwise, take the greater of ; (a) the first element of the list ; (b) the greatest remaining element (max (car numbers) (greatestoflist (cdr numbers))))))
Here's an alternative version, based on a design from some students in a Spring 2003 session of CSC 151. Many students in the class participated in the design, but Andy Cook and Brett McMillian provided the key ideas. Sam Rebelsky wrote the extra documentation.
(define newgreatestoflist (lambda (numbers ) (newgreatestoflisthelper numbers (max (car numbers) (cadr numbers)) 2))) ;;; Procedure: ;;; newgreatestoflisthelper ;;; Parameters: ;;; numbers, a list of numbers ;;; greatestsofar, a number ;;; position, an integer ;;; Purpose: ;;; Find the greatest value in a sublist of numbers. ;;; Produces: ;;; greatest, a number ;;; Preconditions: ;;; position >= 0 [Unverified] ;;; position <= (length numbers) [Unverified] ;;; numbers contains only real numbers (no complex numbers). [Unverified] ;;; greatestsofar is a real number (not complex). [Unverified] ;;; Postconditions: ;;; greatest is the greatest of (a) greatestsofar and (b) elements ;;; position .. last of numbers. (See greatestoflist for what ;;; it means to be greatest.) (define newgreatestoflisthelper (lambda (numbers greatestsofar position) ; If we run off the end of the list, use the greatestsofar (if (>= position (length numbers)) greatestsofar ; Otherwise, update your guess and continue (newgreatestoflisthelper numbers (max greatestsofar (listref numbers position)) (+ position 1)))))
a. Which version do you prefer? Why?
b. Experiment with the two versions to verify that they work as advertised.
c. There's at least one kind of list for which one of the procedures works and one of the procedures doesn't. Can you tell which one?
Here's yet another version of greatestoflist
, one based
on newgreatestoflist
.
(define newergreatestoflist (lambda (numbers) (newergreatestoflisthelper (car numbers) (cdr numbers)))) (define newergreatestoflisthelper (lambda (greatestsofar remainingnumbers) ; If no elements remain ... (if (null? remainingnumbers) ; Use the greatest value seen so far greatestsofar ; Otherwise, update the guess using the next element ; and continue (newergreatestoflisthelper (max greatestsofar (car remainingnumbers)) (cdr remainingnumbers)))))
a. Verify experimentally that this procedure works correctly.
b. How is this procedure similar to newgreatestoflisthelper
?
How is it different? What do you think the advantages and disadvantages
of the changes are?
c. Which version do you prefer? Why?
Define and test a Scheme procedure, (product values)
,
that takes a list of numbers as its argument and returns the result of
multiplying them all together. For example,
> (product (list 3 5 8)) 120 > (product (list 1 2 3 4 5 0)) 0
Warning: (product null)
should not be 0. It should be the identity for multiplication,
just as (sum null)
is the identity for addition.
Explain why.
Write a Scheme procedure, (closesttozero values)
,
that, given a list of numbers (including both negative and positive
numbers), returns the value closest to zero in the list.
Define and test a Scheme procedure, (squareeachelement
values)
, that takes a list of numbers as its argument and
returns a list of their squares.
> (squareeachelement (list 7 3 12 0 4/5))
(49 9 144 0 16/25)
Hint: For the base case, consider what the procedure should return when given a null list; for the other case, separate the car and the cdr of the given list and consider how to operate on them so as to construct the desired result.
If you find that you finish this laboratory early, you can start the next laboratory on list recursion.
http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/History/Labs/recursion.html
[Skip to Body]
Primary:
[Front Door]
[Current]
[Glance]

[EC]
[Honesty]
[Instructions]
[Links]
[Search]
[Syllabus]
Groupings:
[EBoards]
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Lab Writeups]
[Outlines]
[Project]
[Readings]
[Reference]
ECA:
[About]
[Grades]
[Quizzes]
[Submit Work]
[Change Password]
[Reset Password]
Misc:
[Scheme Reference]
[Scheme Report]
[CS151 2003S Gum]
[CS151 2002F]
[CS151 History]
[SamR]
Disclaimer:
I usually create these pages on the fly
, which means that I rarely
proofread them and they may contain bad grammar and incorrect details.
It also means that I tend to update them regularly (see the history for
more details). Feel free to contact me with any suggestions for changes.
This document was generated by
Siteweaver on Tue May 6 09:29:13 2003.
The source to the document was last modified on Fri Feb 14 14:49:01 2003.
This document may be found at http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2003S/Labs/recursion.html
.
; ; Check with Bobby
Samuel A. Rebelsky, rebelsky@grinnell.edu