Fundamentals of CS I (CS151 2001S)

[Current]
[Discussions]
[Glance]
[Honesty]
[Instructions]
[Links]
[News]
[Search]
[Syllabus]
**Primary**

[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Quizzes]
[Readings]
[Reference]
**Sets**

[Blackboard]
[Scheme Report]
[SamR's Schedule]
[Rebelsky/Fall 2000]
[Walker/Fall2000]
[Stone/Spring2000]
**Links**

In this lab, you will explore the basic operations for working with lists and symbolic values. You may want to refer to the corresponding reading as you work on this lab.

Procedures used in this lab:
`append`

,
`car`

,
`cdr`

,
`cons`

,
`length`

,
`list`

,
`list-ref`

, and
`reverse`

.

- Exercises
- Exercise 0: Preparation
- Exercise 1: Two simple lists
- Exercise 2: Interpreting compound
`cons`

es - Exercise 3: Using the
`list`

procedure - Exercise 4: Building a list of symbols
- Exercise 5: Empty lists
- Exercise 6: Repeated elements
- Exercise 7: A small
`cdr`

- Exercise 8: Extracing information from empty lists
- Exercise 9: Extracting information from symbols
- Exercise 10: Compound lists
- Exercise 11: It's all Greek to me
- Exercise 12: How long is emptiness?
- Exercise 13: Checking your own length
- Exercise 14: Length of compound lists
- Exercise 15: Reversing lists
- Exercise 16: Reversing compound lists
- Exercise 17: Joining lists
- Exercise 18: Listing lists
- Exercise 19: Consing lists
- Exercise 20: Extracing elements
- Exercise 21: Wrapup

- Notes

Start DrScheme.

a. Call the `cons`

procedure to create a list that has the number 1 as its first and only
element. The result of your call should be
`(1)`

.

b. Call the `cons`

procedure to create a list that has the symbols `a`

nd
`b`

as its two elements. The result of your call should be
`(a b)`

.

`cons`

esa. Figure out (without using DrScheme) the result of the following expression.

(cons 'alpha (cons 'beta (cons 'gamma (cons 'delta null))))

b. Check your answer by asking DrScheme to evaluate this expression.

`list`

procedure
Call the procedure `list`

, supplying the numerals
`17`

and `43`

as arguments. Describe the value
returned by the procedure.

a. How would you call the `list`

procedure to create a list
containing the symbols `alpha`

, `beta`

, and
`gamma`

, in that order?

b. Verify your answer by entering the code in DrScheme.

How would you invoke the `list`

procedure to create an
empty list?

Determine by experiment whether it is possible to create a list in which the same element occurs more than once.

`cdr`

a. What is the `cdr`

of a
one-element list?

b. Verify your answer by experimentation.

It makes no sense to apply the `car`

and `cdr`

procedures to an empty list,
because there's no way to split off the ``first element'' of a list
that has no elements. What happens if you try it anyway? Find out by
having DrScheme evaluate a deliberately incorrect procedure call.

a. Does it make sense to apply `car`

and `cdr`

to
values other than lists? Why or why not?

b. Determine what happens if you apply these procedures to symbolic values and numeric values.

a. Create the list `(e)`

b. Create the list `(d (e))`

c. Create the lsit `(b c)`

d. Create the list `(a (b c) (d (e)))`

Use Scheme to give the name `Greek-letters`

to the list
constructed by the expression ```
(list 'alpha 'beta (list 'gamma-1
'gamma-2) 'delta)
```

. Then call the
`length`

procedure to
confirm that it has four elements.

Determine the length of the empty list.

a. Create a list of length 5. I don't care what's in the list.

b. Check your answer by having Scheme compute the length of that list.

a. Create the list `(a (b c) (d (e)))`

b. What do you think the length of this list should be?

c. Experimentally determine the length of this list.

d. Explain the result.

Use Scheme to compute the reversal of the list whose elements are the
symbols `senior`

, `junior`

, `sophomore`

,
and `freshling`

, in that order.

a. If a list has another list as one of its elements, should
`reverse`

reverse
that inner list as well as the outer one?

b. Find out by experiment what Scheme does.

Use Scheme to find the result of stringing together (with `append`

) a list with the
symbols `alpha`

and `beta`

as its elements and a
list with the numbers 1, 2, and 3 as its elements. How many elements
does the resulting list have?

a. Invoke the procedure `list`

, applying it to the two
lists that you strung together in the previous exercise: a list with the
symbols `alpha`

and `beta`

as its elements and a
list with the numbers 1, 2, and 3 as its elements.

b. How many elements does the resulting list have?

c. The answer to this question is different from the answer to the question at the end of the previous exercise -- why?

a. Write a call to the procedure `cons`

, applying it to our
favorite two lists: a list with the symbols `alpha`

and
`beta`

as its elements and a list with the numbers 1, 2, and
3 as its elements.

b. How many elements does the resulting list have?

c. Why is the answer to this question different from the answers to the questions at the end of the previous two exercises.

Write a call to the `list-ref`

procedure that
will extract the fourth element of the list

(38 72 apple -1/3 sample)

That is, you should extract the number -1/3.

Quit DrScheme and log out of the workstation.

The `append`

procedure
joins together the elements of a list to make a new list. Hence, when
you append two lists together, the total number of elements in the new
list is the sum of the number of elements in the lists.

The `list`

procedure
creates a new list whose elements are the parameters to `list`

. Hence, if `list`

takes two parameters, the
length of the result is always two, regardless of what those parameters
are.

The `cons`

procedure
builds a new list by placing its first parameter at the start of its
second parameter (which is a list). Hence, the length of the result is
one more than the length of the second parameter.

2 Septemer 1997 [John David Stone]

- Created

31 March 2000 [John David Stone]

- Last revised

Friday, 1 September 2000 [Samuel A. Rebelsky]

- Split into separate sections from
a similar document from previous semesters. That document was available at
`http://www.math.grin.edu/~stone/courses/scheme/symbols-and-lists.xhtml`

. - Updated for CSC151.02 Fall 2000

Sunday, 28 January 2001 [Samuel A. Rebelsky]

- Added links to new reference pages.
- Added introductory summary of procedures used.
- Updating formatting for CSC151 Spring 2001.
- Added notes on problems 18 and 19.

Monday, 29 January 2001 [Samuel A. Rebelsky]

- Slight update to the first
`list`

problem to handle in-class questions.

[Current]
[Discussions]
[Glance]
[Honesty]
[Instructions]
[Links]
[News]
[Search]
[Syllabus]
**Primary**

[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Quizzes]
[Readings]
[Reference]
**Sets**

[Blackboard]
[Scheme Report]
[SamR's Schedule]
[Rebelsky/Fall 2000]
[Walker/Fall2000]
[Stone/Spring2000]
**Links**

**Disclaimer**:
I usually create these pages on the fly. This means that they
are rarely proofread and may contain bad grammar and incorrect details.
It also means that I may update them regularly (see the history for
more details). Feel free to contact me with any suggestions for changes.

This page was generated by Siteweaver on Thu May 3 23:07:50 2001.

This page may be found at `http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2001S/lists.html`

.

You may validate
this page's HTML.

The source was last modified Mon Jan 29 09:25:38 2001.