Fundamentals of Computer Science I: Media Computing (CS151.01 2008S)
Primary: [Front Door] [Syllabus] - [Academic Honesty] [Instructions]
Current: [Outline] [EBoard] [Reading] [Lab] [Assignment]
Groupings: [Assignments] [EBoards] [Examples] [Exams] [Handouts] [Labs] [Outlines] [Projects] [Readings]
References: [A-Z] [Primary] [Scheme Report (R5RS)] [Scheme Reference] [DrScheme Manual]
Related Courses: [CSC151.02 2008S (Davis)] [CSC151 2007F (Rebelsky)] [CSC151 2007S (Rebelsky)] [CSCS151 2005S (Stone)]
Summary: In this laboratory, you will explore some basic concepts in recursing over lists.
Reference:
Here are the definitions from the reading.
;;; Procedure: ;;; sum ;;; 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 numbers. ;;; 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)))))) ;;; Procedure: ;;; rgb-filter-out-dark ;;; Parameters: ;;; colors, a list of RGB colors. ;;; Purpose: ;;; Create a new list of colors, consiting only of non-dark colors. ;;; Produces: ;;; not-dark, a list of RGB colors. ;;; Preconditions: ;;; rgb-dark? is defined. ;;; Postconditions: ;;; Every element of not-dark appears in colors. ;;; If (not (rgb-dark? (list-ref colors i))) holds for some i, ;;; then the corresponding color appears in not-dark. (define rgb-filter-out-dark (lambda (colors) (if (null? colors) null (if (rgb-dark? (car colors)) (rgb-filter-out-dark (cdr colors)) (cons (car colors) (rgb-filter-out-dark (cdr colors)))))))
The latter procedure requires rgb-dark?
, which follows.
;;; Procedure: ;;; rgb-dark? ;;; Parameters: ;;; color, an RGB color ;;; Purpose: ;;; Determine if the color appears dark. ;;; Produces: ;;; dark?, a Boolean ;;; Preconditions: ;;; [No additional] ;;; Postconditions: ;;; If color is relatively dark, then dark? is #t. ;;; Otherwise, dark? is #f. (define rgb-dark? (lambda (color) (> 33 (rgb-brightness color)))) ;;; Procedure: ;;; rgb-brightness ;;; Parameters: ;;; color, an RGB color ;;; Purpose: ;;; Computes the brightness of color on a 0 (dark) to 100 (light) scale. ;;; Produces: ;;; b, an integer ;;; Preconditions: ;;; color is a valid RGB color. That is, each component is between ;;; 0 and 255, inclusive. ;;; Postconditions: ;;; If color1 is likely to be perceived as lighter than color2, ;;; then (brightness color1) > (brightness color2). (define rgb-brightness (lambda (color) (round (* 100 (/ (+ (* 0.30 (rgb-red color)) (* 0.59 (rgb-green color)) (* 0.11 (rgb-blue color))) 255)))))
In this laboratory, we will not be working with images (just with colors and with lists), so you need not create an image.
a. Copy the sum
and
rgb-filter-out-dark
procedures to your definitions
pane.
b. Copy the rgb-dark?
and
rgb-brightness
procedures to your library.
c. Load your library.
d. Create a list of a dozen or so colors (red, black, green, blue, yellow,
orange, magenta, white, black, etc.). Name it my-colors
.
a. Read through sum
so that you have a sense of its
purpose.
b. Verify that sum
produces the same result as in the corresponding reading.
c. What value do you expect sum
to produce for the empty
list? Check your answer experimentally.
d. What value do you expect sum
to produce for
a singleton list? Check your answer experimentally.
e. Try sum
for a few other lists, too.
a. Read through the definition of rgb-filter-out-dark
to
try to understand what it does.
b. Determine which colors in my-colors
are dark with
(map rgb-dark? my-colors)
.
c. Create a list of non-dark colors with (rgb-filter-out-dark
my-colors)
.
d. Verify that all the resulting colors are not dark.
Suppose the length
procedure were not defined. We could
define it by recursing through the list, counting 1 for each value in the
list. In some sense, this is much like the definition of sum
,
except that we use the value 1 rather than the value of each element.
a. Using this idea, write a procedure,
(
that finds the length of a list (without using
my-length
lst
)length
).
b. Check your answer on a few examples: the empty list, the list of colors you created, a few more lists of your choice.
Write a procedure, (
, that, given a list of numbers,
computes the product of those numbers. You should feel free to use
product
nums
)sum
as a template. However, you should think
carefully about the base case.
What if we don't want to count every value in a list? For example, what if we only want to count the dark values in a list of colors. In this case, we still recurse through the list, but we sometimes count 1 (when the color is dark) and sometimes count 1 (when the color is not dark).
a. Using this idea, write a procedure,
(
, that, given a list of colors,
counts how many are dark.
rgb-tally-dark
colors
)
b. Test your procedure.
In the past, we've found it useful to find the average of two colors. Let's
consider how we might find the average of a list of colors. First, we
would need to find the number of colors in the list. That's easy, we just
use the length
procedure. Next, we need to find the sum of
each component. That's a bit harder, but let's suppose we can do it.
We next divide each sum by the length, and get the average of
that component. Finally, we put it all together with rgb-new
.
That is, we might write
(define rgb-average (lambda (colors) (rgb-new (/ (sum-red colors) (length colors)) (/ (sum-green colors) (length colors)) (/ (sum-blue colors) (length colors)))))
Of course, for this to work, we need to write sum-red
,
sum-blue
, and sum-green
. For
now, we'll write one of the three. (One we've written that one,
the other two should be obvious.)
a. Write a procedure, (
, that computes the sum of the
red components in a color. You should use direct recursion in your
definition sum-red
colors
)sum-red
. You may want to base your
definition on the definition of sum
.
b. Test your procedure on a list of a single color.
c. Test your procedure on the my-colors
list you wrote earlier.
d. It is possible to write sum-red
without
using direct recursion. How? An appropriate combination of
map
and sum
. Try doing so.
(If you can't find a solution, look at the notes on this problem.)
Write a procedure, (
, that filters out all elements
of filter-reds
colors
)colors
with a red component of at least 128.
Write a procedure, (
, that filters out all
elements of spots-bound
spots
left
top
right
bottom
)spots
which do not appear in the
rectangle bounded at the left by left
,
at the top by top
, at the right
by right
, and at the bottom by
bottom
.
For example, if left
is 5,
top
is 10, right
is 8,
and bottom
is 20, the procedure should remove
any spots whose column is less than 5 or more than 8 or whose row is
less than 10 or more than 20.
Write a procedure,
(
,
that, given a nonempty list of colors, finds the darkest of those
colors.
rgb-darkest
colors
)
Write a procedure, (
, that, given a list of real
numbers (including both positive and negative numbers), returns the
value closest to zero in the list.
closest-to-zero
values
)
Hint: Think about how, given two numbers, you determine which is closer to zero.
Hint: Think about how this problem is similar to a problem or problems we've solved before.
Write a procedure, (
, that, given a list of spots,
returns a list of the distance between neighboring spots in the
list. For example,
spot-distances
spots
)
For example,
>
(define some-spots (list (spot-new 0 0 "red") (spot-new 10 0 "orange") (spot-new 10 8 "yellow") (spot-new 6 8 "green") (spot-new 6 5 "blue") (spot-new 9 9 "indigo") (spot-new 10 10 "violet")))
>
(spot-distances some-spots)
(10 8 4 3 5 1.4142135)
Notice that spot-distances
returns a list whose
length is one less than the length of its input list.
Write a procedure, (
, that, given a list of colors,
computes a new list of colors, by averaging subsequent pairs of
colors. For example, if the input list is the standard seven
rainbow colors (red, orange, yellow, green, blue, indigo, and violet),
the output list will consist of
a red-orange average, an orange-yellow average, a yellow-green
average, a green-blue average, a blue-indigo average, and an
indigo-violet average.
rgb-averages
colors
)
Once again, the length of the result list is one less than the length of the input list.
Write (
without using
image-render-spots!
image
spots
)map
or foreach!
.
We can use map
to extract the red component of
each color.
(map rgb-red colors)
That gives us a list of numbers, which we can sum with sum
.
(sum (map rgb-red colors))
Putting it all together in a procedure, we get
(define sum-red (lambda (colors) (sum (map rgb-red colors))))
Primary: [Front Door] [Syllabus] - [Academic Honesty] [Instructions]
Current: [Outline] [EBoard] [Reading] [Lab] [Assignment]
Groupings: [Assignments] [EBoards] [Examples] [Exams] [Handouts] [Labs] [Outlines] [Projects] [Readings]
References: [A-Z] [Primary] [Scheme Report (R5RS)] [Scheme Reference] [DrScheme Manual]
Related Courses: [CSC151.02 2008S (Davis)] [CSC151 2007F (Rebelsky)] [CSC151 2007S (Rebelsky)] [CSCS151 2005S (Stone)]
Copyright (c) 2007-8 Janet Davis, Matthew Kluber, and Samuel A. Rebelsky. (Selected materials copyright by John David Stone and Henry Walker and used by permission.)
This material is based upon work partially supported by the National Science Foundation under Grant No. CCLI-0633090. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
This work is licensed under a Creative Commons
Attribution-NonCommercial 2.5 License. To view a copy of this
license, visit http://creativecommons.org/licenses/by-nc/2.5/
or send a letter to Creative Commons, 543 Howard Street, 5th Floor,
San Francisco, California, 94105, USA.