Fundamentals of CS I (CS151 2002F)

**Primary:**
[Skip To Body]
[Front Door]
[Current]
[Glance]
[Honesty]
[Instructions]
[Links]
[Search]
[Syllabus]

**Groupings:**
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Readings]
[Reference]

**ECA:**
[About]
[Grades]
[Quizzes]
[Submit Work]
[Change Password]
[Reset Password]

**Miscellaenous:**
[Scheme Reference]
[CS151 2002F Gum]
[CS151 2001S]
[SamR]
[Glimmer Labs]
[schemers.org]

Start DrScheme.

`let`

What are the values of the following `let`

-expressions?
You may use DrScheme to help you answer these questions, but be sure you
can explain how it arrived at its answers.

a.

(let ((tone "fa") (call-me "al")) (list call-me tone "l" tone))

b.

;; Solutions to the quadratic equation x^2 - 5x + 4: (let ((discriminant (- (* -5 -5) (* 4 1 4)))) (list (/ (+ (- -5) (sqrt discriminant)) (* 2 1)) (/ (- (- -5) (sqrt discriminant)) (* 2 1))))

c.

(let ((total (+ 8 3 4 2 7))) (let ((mean (/ total 5))) (* mean mean)))

Write a nested `let`

-expression that binds a total of five
names, `alpha`

, `beta`

, `gamma`

,
`delta`

, and `epsilon`

, with `alpha`

bound to 9387 and each subsequent name bound to a value twice
as large as the one before it -- `beta`

should be
twice as large as `alpha`

, `gamma`

twice as
large as `beta`

, and so on. The body of the innermost
`let`

-expression should then compute the sum of the values
of the five names.

Write a `let*`

-expression equivalent to the
`let`

-expression in the previous exercise.

Consider the following procedure that squares all the values in a list.

;;; Procedure: ;;; square-values ;;; Parameters: ;;; lst, a list of numbers of the form (num_1 num_2 ... num_n) ;;; Purpose: ;;; Squares all the values in lst. ;;; Produces: ;;; list-of-squares, a list of numbers ;;; Preconditions: ;;; [Standard] ;;; Postconditions: ;;; list-of-squares has the form (square_1 square_2 ... square_n) ;;; For all i, square_i is the square of num_i (that is num_i * num_i). (define square-values (lambda (lst) (let ((square (lambda (val) (* val val)))) (if (null? lst) null (cons (square (car lst)) (square-values (cdr lst)))))))

a. Verify that `square-values`

works correctly.

b. Try to execute `square`

outside of `square-values`

.
Explain what happens.

Here is a procedure that takes a non-empty list of strings as an argument and returns the longest string on the list (or one of the longest strings, if there is a tie).

;;; Procedure: ;;; longest-string-in-list ;;; Parameters: ;;; los, a list of strings ;;; Purpose: ;;; Finds one of the longest strings in los. ;;; Produces: ;;; longest, a list ;;; Preconditions: ;;; los is a nonempty list. ;;; every element of los is a string. ;;; Postconditions: ;;; Does not affect los. ;;; Returns an element of los. ;;; No element of los is longer than longest. (define longest-string-in-list (lambda (los) ; If there is only one string, that string must be the longest. (if (null? (cdr los)) (car los) ; Otherwise, take the longer of the first string and the ; longest remaining string. (longer-string (car los) (longest-string-in-list (cdr los))))))

This definition of the `longest-string-in-list`

procedure
includes a call to the `longer-string`

procedure, which returns
the longer of two given strings:

;;; Procedure: ;;; longer-string ;;; Parameters: ;;; left, a string ;;; right, a string ;;; Purpose: ;;; Find the longer of left and right. ;;; Produces: ;;; longer, a string ;;; Preconditions: ;;; Both left and right are strings. ;;; Postconditions: ;;; longer is a string. ;;; longer is either equal to left or to right. ;;; longer is at least as long as left. ;;; longer is at least as long as right. (define longer-string (lambda (left right) (if (<= (string-length right) (string-length left)) left right)))

Revise the definition of `longest-string-in-list`

so that the
name `longer-string`

is bound to the procedure that it denotes
only locally, in a `let`

-expression.

Note that there are at least two possible ways to do the previous exercise:
The definiens of
`longest-string-in-list`

can be a `lambda`

-expression
with a `let`

-expression as its body, or it can be a
`let`

-expression with a `lambda`

-expression as its
body. That is, it can take the form

(define longest-string-in-list (let (...) (lambda (los) ...)))

or the form

(define longest-string-in-list (lambda (los) (let (...) ...)))

a. Define `longest-list-in-list`

in whichever way that you did not
define it for the previous exercise.

b. Does the order of nesting affect what happens when the procedure is invoked? If so, which arrangement is better? Why?

In fact, the two definitions you came up with in the previous exercises
are not the only alternatives you have in placing the `let`

.
Since `longer-string`

is only needed in the recursive case,
you can place the `let`

there.

(define longest-string-in-list (lambda (los) ; If there is only one string, that string must be the longest. (if (null? (cdr los)) (car los) ; Otherwise, take the longer of the first string and the ; longest remaining string. (let ((longer-string (lambda (left right) (if (<= (string-length right) (string-length left)) left right)))) (longer-string (car los) (longest-string-in-list (cdr los))))))

Including the original definition, you've now seen or written four
variants of `longest-string-in-list`

. Which do you prefer?
Why?

Extend your favorite version of `longest-string-in-list`

so
that it verifies its preconditions (i.e., that `los`

only
contains strings and that `los`

is nonempty). If the
preconditions are not met, your procedure should return `#f`

.

It is perfectly acceptable for you to check each list element in turn to determine whether or not it is a string, rather than to check them all at once, in advance.

Monday, 2 October 2000 [Samuel A. Rebelsky]

- Created. Many of the problems were taken from
`http://www.cs.grinnell.edu/~stone/courses/scheme/local-bindings.xhtml`

- This version is available as
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2000F/Labs/local-bindings.html`

Wednesday, 28 February 2001 [Samuel A. Rebelsky]

- Removed a problem created last semester but inappropriate for this semester's class.
- Added comments in the longest string exercise and fixed some errors that I'd introduced into that exercise. (Bad Sam!)
- Added exercises 6 and 7 (further followups on the longest string exercise).
- Updated formatting.

Thursday, 1 March 2001 [Samuel A. Rebelsky]

- Updated problem 2 to use the names
`alpha`

to`epsilon`

rather than`a`

to`e`

because the`a`

was too frequently read as an article rather than a name. - This version is available as
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2001S/Labs/let.html`

.

Monday, 7 October 2002 [Samuel A. Rebelsky]

- Updated slightly.

Tuesday, 8 October 2002 [Samuel A. Rebelsky]

- Inserted exercise 4 (a simple test of local procedures).
- This version is available as
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2002F/Labs/let.html`

.

Wednesday, 9 October 2002 [Samuel A. Rebelsky]

- Updated final problem slightly (clarified what the procedure should do if the preconditions were not met).
- This version is available as
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2002F/Labs/let.html`

.

**Primary:**
[Skip To Body]
[Front Door]
[Current]
[Glance]
[Honesty]
[Instructions]
[Links]
[Search]
[Syllabus]

**Groupings:**
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Readings]
[Reference]

**ECA:**
[About]
[Grades]
[Quizzes]
[Submit Work]
[Change Password]
[Reset Password]

**Miscellaenous:**
[Scheme Reference]
[CS151 2002F Gum]
[CS151 2001S]
[SamR]
[Glimmer Labs]
[schemers.org]

**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 Mon Dec 2 09:18:57 2002.

The source to the document was last modified on Wed Oct 9 10:03:27 2002.

This document may be found at `http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2002F/Labs/let.html`

.

You may wish to validate this document's HTML ; ; Check with Bobby

Samuel A. Rebelsky, rebelsky@grinnell.edu