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]

a. If you have not done so already, please scan the corresponding reading on higher-order procedures.

b. Start DrScheme

`map`

Recall that `(map proc lst)`

builds a list by applying
`proc`

to each element of `lst`

in succession.

a. Use `map`

to compute the successors to the squares of
the integers between 1 and 10. Your result should be
the list `(2 5 10 17 26 37 50 65 82 101)`

.

b. Use `map`

to turn a list into an association list by
making each value in the first list into a a key. For example,
given a list of names, you might produce an association list that
associates the grade "A" with that name. Given the list
`("William" "Jonathan" "Daniel")`

you should produce
the list `(("William" "A") ("Jonathan" "A") ("Daniel A"))`

.

c. Use `map`

to take the last element of each list in a
list of lists. The result should be a list of the last elements.
For example, given `((1 2 3) (4 5 6) (7 8 9 10) (11 12))`

as input, you should produce the list `(3 6 10 12)`

.

d. Use `apply`

and `map`

to sum the last elements
of each list in a list of lists of numbers. The result should be a
number.

Note that you should have written a similar expression for another lab. Your goal here is to see whether you can solve the problem more concisely.

Although we often use the `map`

procedure with only two
parameters (a procedure and a list), it can take more than two
parameters, as long as the first parameter is a procedure and the
remaining parameters are lists.

a. What do you think the value of the following expression will be?
`(map (lambda (x y) (+ x y)) (list 1 2 3) (list 4 5 6))`

b. Verify your answer through experimentation.

c. What do you think the value of the following expression will be?
`(map list (list 1 2 3) (list 4 5 6) (list 7 8 9))`

d. Verify your answer through experimentation.

e. What do you think Scheme will do when evaluating the following expression?
`(map list (list 1 2 3) (list 4 5))`

f. Verify your answer through experimentation.

g. What do you think Scheme will do when evaluating the following expression?
`(map (lambda (x y) (+ x y)) (list 1 2) (list 3 4) (list 5 6))`

h. Verify your answer through experimentation.

Use `apply`

and `map`

to concisely define a
procedure, `(dot-product `

, that
takes as arguments two lists of numbers, equal in length, and returns
the sum of the products of corresponding elements of the arguments:
*list1* *list2*)

>(dot-product (list 1 2 4 8) (list 11 5 7 3))73 ; ... because (1 x 11) + (2 x 5) + (4 x 7) + (8 x 3) = 11 + 10 + 28 + 24 = 73 >(dot-product null null)0 ; ... because in this case there are no products to add

Sarah and Steven Schemer suggest that

they say, `apply`

is irrelevant.
After all,when you write

(apply proc (arg1 ... argn))

you're just doing the same thing as

(proc arg1 arg2 ... argn)

.

Given your experience in the previous exercise, are they correct? Why or why not?

a. Document and write a procedure, `(tally `

,
that counts the number of values in *predicate*
*list*)*list* for which
*predicate* holds.

b. Demonstrate the procedure by tallying the number of odd values in the list of the first twenty integers.

c. Demonstrate the procedure by tallying the number of multiples of three in the list of the first twenty integers.

Document and write a procedure, `(make-tallier `

,
that builds a procedure that takes a list as a parameter and tallies
the values in the list for which the predicate holds. For example
*predicate*)

>(define count-odds (make-tallier odd?))>(count-odds (list 1 2 3 4 5))3

You can assume that `tally`

already exists for the purpose
of this problem.

Thursday, 2 November 2000 [Samuel A. Rebelsky]

- Created. Problems generally taken from elsewhere and reworded slightly.
- This version available at
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2000F/Labs/hop.html`

Wednesday, 14 February 2001 [Samuel A. Rebelsky]

- Moved many problems into a new lab so that there are now two higher-order procedures labs.
- Added new problems (1, 4, and 5).
- Removed unused notes section.

Sunday, 8 April 2001 [Samuel A. Rebelsky]

- Fixed a small formatting problem.
- This version available at
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2001S/Labs/higher-order.html`

Tuesday, 15 October 2002 [Samuel A. Rebelsky]

- Reformatted slightly.
- Added some introductory notes.

Wednesday, 16 October 2002 [Samuel A. Rebelsky]

- Added some examples in problem 1.
- Added a new problem 2 that explores
`map`

. - This version available at
`http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2002F/Labs/higher-order.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:52 2002.

The source to the document was last modified on Wed Oct 16 10:25:56 2002.

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

.

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

Samuel A. Rebelsky, rebelsky@grinnell.edu