- Held
- Friday, 15 March 2019
- Writeup due
- Monday, 1 April 2019
- Summary
- In this laboratory, you will explore recursive procedures
in which we pass along intermediate computations, most typically
using a
*recursive helper procedure*. When this technique is used in conjunction with a program structure in which the recursive result is returned directly (without accumulated actions to perform), this technique supports*tail recursion*.

a. Discuss the self check with your partner.

b. Do the normal lab setup. That is

- Start DrRacket.
- Make sure that the
`loudhum`

package is up to date. - Add
`(require loudhum)`

to the top of the definitions pane.

c. Make a copy of the annotated `new-sum-helper`

procedure from the reading,
as well as `new-sum`

and any accompanying documentation.

d. Verify that `new-sum-helper`

does, in fact, print the expected
information about intermediate procedure calls.

a. Add the following code (taken from the reading) to your definitions pane.

```
;;; Procedure:
;;; furthest-from-zero
;;; Parameters:
;;; numbers, a nonempty list of real numbers
;;; Purpose:
;;; Find the number in the list with the largest absolute value.
;;; Produces:
;;; furthest, a real number
;;; Preconditions:
;;; [No additional]
;;; Postconditions:
;;; furthest is an element of numbers
;;; For any number, n, in numbers
;;; (>= (abs furthest) (abs n))
(define furthest-from-zero
(lambda (numbers)
(furthest-from-zero-helper (car numbers) (cdr numbers))))
(define furthest-from-zero-helper
(lambda (furthest-so-far numbers-remaining)
(if (null? numbers-remaining)
furthest-so-far
(furthest-from-zero-helper
(further-from-zero furthest-so-far (car numbers-remaining))
(cdr numbers-remaining)))))
;;; Procedure:
;;; further-from-zero
;;; Parameters:
;;; val1, a real number
;;; val2, a real number
;;; Purpose:
;;; Choose whichever of val1 and val2 is further from zero.
;;; Produces:
;;; further, a real number
;;; Preconditions:
;;; [No additional]
;;; Postconditions:
;;; further is either val1 or val2
;;; (abs further) >= (abs val1)
;;; (abs further) >= (abs val2)
(define further-from-zero
(lambda (val1 val2)
(if (>= (abs val1) (abs val2))
val1
val2)))
```

b. Add appropriate calls to `display`

and `newline`

so that
you can track all the calls to `furthest-from-zero-helper`

and
`further-from-zero`

.

c. Sketch (that is, compute by hand) the output you expect to see in
call to `(furthest-from-zero (list -3 5 6 -2 1 -5))`

. Your
sketch might start something like the following.

```
(furthest '(-3 5 6 -2 1 -5))
=> (helper -3 '(5 6 -2 1 -5))
=> (helper (further '-3 5) '(6 -2 1 -5))
=> (helper 5 '(6 -2 1 -5))
...
```

d. Check your answer by asking DrRacket to evaluate that expression.

a. Rewrite the `product`

procedure, which computes the product of a list
of values, using the same technique used for `new-sum`

.

b. Write a similar `my-quotient`

procedure. (Do *not* call it `quotient`

,
which is a built-in procedure that is commonly used.)

For example,

```
> (my-quotient (list 3))
3
> (my-quotient (list 3 5))
3/5
> (my-quotient (list 3 5 7))
3/35
> (my-quotient (list 3 5 7 6))
1/70
> (my-quotient (list 3 5 7 6 1/10))
1/7
```

Do *not* use `product`

as a helper.

You may recall that in the previous lab, you
wrote a procedure, `tally-numbers`

, that took as input a list of mixed
values (both numbers and non-numbers) and returned a count of the number
of numbers in the list.

We will be rewriting `tally-numbers`

using helper recursion. The helper
procedure will likely have two parameters: a count of all the numbers
you’ve seen so far and a list of all the values you have left to look at.

a. Make a table with two column labels: `count-so-far`

and `remaining`

.
Here’s what we might expect those columns to have after we’ve done
the first few steps of the helper on the list `'(5 a b 1 c 2 3 b 4)`

```
tally-so-far remaining
------------ ---------
0 '(5 a b 1 c 2 3 b 4)
1 '(a b 1 c 2 3 b 4)
1 '(b 1 c 2 3 b 4)
1 '(1 c 2 3 b 4)
2 '(c 2 3 b 4)
```

Fill in the next rows to suggest what might/should happen.

b. Using the ideas you gained in those steps, implement `tally-numbers`

and `tally-numbers-helper`

.

c. Check your answers on some of the following lists

```
> (tally-numbers null)
> (tally-numbers (list 1 2 3))
> (tally-numbers (list "a" "b" "c"))
> (tally-numbers (list 1 "a" 2 "b" 3 "c"))
```

d. Update `tally-numbers-helper`

to print out calls, and call it
on the list `'(5 a b 1 c 2 3 b 4)`

to see if it matches your
answer to part a.

You may recall that in the reading on recursion
basics, we wrote a procedure,
`select-numbers`

, that, given a list of values, returns a list with
just the numbers from the original list.

Here’s an attempt to implement that procedure using helper recursion.

```
;;; Procedure:
;;; select-numbers
;;; Parameters:
;;; values, a list of Scheme values
;;; Purpose:
;;; Create a new list values which consists of only the numbers
;;; in values.
;;; Produces:
;;; nums, a list of Scheme values
;;; Preconditions:
;;; [No additional]
;;; Postconditions:
;;; * number? holds for every value in nums.
;;; * Every element of values for which number? holds appears in nums.
;;; * Every element of nums appears in values.
;;; * If a number appears multiple times in either list, it appears
;;; the same number of times in both lists.
;;; * The values retain their order.
(define select-numbers
(lambda (values)
(select-numbers-helper null values)))
(define select-numbers-helper
(lambda (nums-so-far remaining)
; (display (list 'select-numbers-helper nums-so-far remaining)) (newline)
(cond
[(null? remaining)
nums-so-far]
[(not (number? (car remaining)))
(select-numbers-helper nums-so-far (cdr remaining))]
[else
(select-numbers-helper (cons (car remaining) nums-so-far)
(cdr remaining))])))
```

a. Add the code and documentation to your definitions pane.

b. As you may have observed in the previous problem, it can be helpful to understand tail recursive procedures by creating a table whose columns are labeled with the parameters and which each row gives the values of those parameters in one call.

Make a table with two column labels: `num-so-far`

and `remaining`

.
Here’s what we might expect those columns to have after we’ve done
the first few steps of the helper on the list `'(a b 1 c 2 3 b 4)`

```
num-so-far remaining
---------- ---------
'() '(a b 1 c 2 3 b 4)
'() '(b 1 c 2 3 b 4)
'() '(1 c 2 3 b 4)
'(1) '(c 2 3 b 4)
```

Fill in the remaining five or so rows.

c. What output do you expect to get from
`(select-numbers '(a b 1 c 2 3 b 4))`

?

d. Check your answer experimentally.

e. If you did not get the answer you expected, uncomment the line that logs procedure calls and run it again.

As you may have noted, the prior implementation of `select-numbers`

produces the list of values in reverse order that they appear in the
original list. Rewrite the procedure so that it produces the list of
values in the same order as they appear in the original list. You
may not use `append`

in that implementation.

You may recall that we claimed that one of the implementations of
`furthest-from-zero`

using direct recursion was incredibly expensive.

Let’s check that claim.

a. Add the following definition of `furthest-from-zero`

to your
definitions pane.

```
(define furthest-from-zero-alt
(lambda (numbers)
(display (list 'furthest-from-zero-alt numbers)) (newline)
(if (null? (cdr numbers))
(car numbers)
(if (>= (abs (car numbers))
(abs (furthest-from-zero-alt (cdr numbers))))
(car numbers)
(furthest-from-zero-alt (cdr numbers))))))
```

b. What output do you expect from the following procedure call? (Detail both the answer and the log messages.)

```
> (furthest-from-zero-alt (list 8 5 3 1 0))
```

c. Check your answer experimentally.

d. What output do you expect from the following procedure call? (Detail both the answer and the log messages.)

```
> (furthest-from-zero-alt (list 0 1 3 5 8))
```

e. Check your answer experimentally.

f. Explain, in your own words, why one of the two results looks so much worse.

g. How many calls to `furthest-from-zero-alt`

do you expect to see
if we ask for the values of `(furthest-from-zero-alt (iota 8))`

?

h. Check your answer experimentally.

As we noted in the reading the problem with `furthest-from-zero-alt`

is that we may have *two* recursive calls each time, rather than one.
That’s dangerous. We suggested a few alternative strategies in the
reading. Let’s consider another one. Suppose we use `let`

to bind
names to the `car`

and the result of of the recursive call.

```
(let ([candidate (furthest-from-zero-alt (cdr numbers))]
[alternate (car numbers)])
```

a. Rewrite `furthest-from-zero-alt`

to use these names in place of the
values they name.

b. What effect do you expect this naming to have on the efficiency of the procedure?

c. Check your answer experimentally.

The following exercises will challenge you to extend the problem-solving strategies you’ve learned so far.

Write a procedure, `tally-numbers-strings-and-symbols`

, that takes
as input a mixed list and produces a list of tallys of the number
of numbers, strings, and values.

```
> (tally-numbers-strings-and-symbols null)
'(0 0 0)
> (tally-numbers-strings-and-symbols '(a 1 2 b "c" 3))
'(3 2 1)
> (tally-numbers-strings-and-symbols '(a b "c" "3" "e"))
'(0 2 3)
```

You will find it useful to base `tally-numbers-strings-and-symbols`

on
the helper-recursive `tally-numbers`

your wrote earlier in this lab.

Rewrite the original `furthest-from-zero`

so that the primary procedure
(that is, `furthest-from-zero`

) checks all of its preconditions before
calling the helper.

The reading provides at least four ways to find the number furthest from zero in a list of numbers. You’ve developed at least one more in this lab. Which do you prefer, and why?