---
title: Eboard 21  Numeric recursion
number: 21
section: eboards
held: 2017-10-11
---
CSC 151.01, Class 21:  Numeric recursion
========================================

_Overview_

* Preliminaries
    * Notes and news
    * Upcoming work
    * Extra credit
    * Questions
* Reflections on Readings
* Lab
* Debrief (?)

### News / Etc.

* Quizzes 6 and 7 returned.  We may want to chat a bit about quiz 6.
* At the end of today's class, you will be half way through CSC 151.
  Congratulations! 
* Quiz Friday: Identify your classmates.
    * Reminder: Send me your nickname if P'Web does not match.
* Review sessions this week are on recursion.  Yay!  (Mentors will also
  have printed picture lists.)

### Upcoming Work

* [Writeup for class 20](../writeups/writeup20) due Wednesday at 10:30 p.m.
    * Exercises 3d and 3e.
    * To: <csc151-01-grader@grinnell.edu>
* [Writeup for class 21](../writeups/writeup21) due Friday at 10:30 p.m.
    * Exercise 5
    * No documentation is necessary!
    * To: <csc151-01-grader@grinnell.edu>
    * Subject: CSC 151.01 Writeup 21 (YOUR NAMES)
* Reading for Friday's class: [Naming local procedures](../readings/letrec)
* Exam 2 cover sheets due NOW!
* Exam 2 epilogue due TONIGHT at 10:30 p.m.

### Extra credit (Academic/Artistic)

* Trio TONIGHT at 7:30 p.m. in Sebring-Lewis.

### Extra credit (Peer)

### Extra credit (Misc)

### Other good things

### Notes on quiz 6

```
;;; Procedure:
;;;   sort-by-latitude
;;; Parameters:
;;;   zips, a list
;;; Purpose:
;;;   Sort the entries of zips by latitude
;;; Produces:
;;;   sorted, a list
;;; Preconditions:
;;;   * zips is a list of lists.
;;;   * (or) Each element of zips is a traditional zip code entry
;;;     of the form (zip latitude longitude cityname statename countyname)
;;;   * Each element of zips is a list of length at least two.
;;;   * The second element (cadr) of each of those lists represents
;;;     latitude.
;;;   * The latitude (cadr) of each of those lists is real.
;;; Postconditions:
;;;   * sorted contains the same set of elements as the original list,
;;;     potentially in a different order. "sorted is a permutation of
;;;     zips"
;;;   * sorted is sorted by latitude in increasing order from least
;;;     to greatest.  For any two consecutive elements of list,
;;;     entry1 and entry2, (< (cadr entry1) (cadr entry2)).
(define sort-by-latitude
  (let ([smaller-latitude
          (lambda (zip1 zip2)
            (< (cadr zip1) (cadr zip2)))])
    (lambda (zips)
      (sort zips smaller-latitude))))
```

### Questions


Reading review
--------------

_Discuss with your partner._

What were the primary points of Monday's class?

* You will find that there are a few templates that work well for
  recursion (and for other tasks).  Look for common solutions and then
  write down the commonality to use in the future.
* How reduce is written: Using a binary procedure to combine elements of
  a list (to find extreme values, or other combinations)
* How to write list predicates.
* Practice with recursion is useful as we learn it.
* Be careful about the number of recursive calls; you can accidentally
  create really inefficient recursive procedures.

What were the primary points of today's reading?

* We can do recursion with numbers as parameters.
* Be careful about the base case and how you get closer to the base case.
  (E.g., if the base case is "the parameter = 1" and you start at -1,
  subtracting 1 does *not* get you closer.
* For numeric recursion, n=0 and n=1 (a.ka. (= n 0) and (= n 1)) are the
  most common base cases.
* Doing a reading the same night the exam is due is hard.
* Sometimes rather than counting down to zero, we count up to n.
* Sometimes instead of adding/subtracting 1, we divide/multiply.

Lab
---

Why am I getting a dot in the middle of my list?
  : If you cons onto something other than a list, DrRacket adds a period
    right before the end to say "this is not a list".

Why doesn't DrRacket just issue an error?
  : `cons` was designed to be used to build things other than lists.

Sam asks: _Can you write `my-iota` without `reverse`?_

Do any of the patterns fit for `my-iota`?
  : Not quite.  But counting upwards is helpful.

Writeup: Exercise 5.  Documentation is not necessary.

Debrief
-------

Let's write `my-iota` without `reverse`.  The hint says to write a helper.
The typical helper has two columns: What we've computed so far and what
we have remaining.

    so-far      remaining
    ------      ---------

How should those start?

so-far starts as null, remaining starts as 5.

What are we going to do at each step?

* subtract 1 from remaining
* add that value to the front of so-far

```
(define my-iota-helper
  (lambda (so-far remaining)
    (display (list 'my-iota-helper so-far remaining)) (newline)
    (if (zero? remaining)
        so-far
        (my-iota-helper (cons (- remaining 1) so-far)
                        (- remaining 1)))))

(define my-iota
  (lambda (n)
    (when (or (not (integer? n)) (negative? n))
      (error "my-iota: Expects non-negative integer, given" n))
    (my-iota-helper null n)))
```