Overview

• We look at general quiz issues.
• We do some sample quiz questions.
• We gather additional questions and arrange them.
• I attempt answers.
• More Q&A, as appropriate.

About the Quiz

Topics

• Recursion
• Recursion with helper procedures
• List recursion
• Numeric recursion
• Patterns of recursion

Some things to know about

• Direct recursion vs. helper recursion
• Patterns of recursion
• The three key ideas of recursion: Base case, simplify, recursive case.

Types of Questions

• What is the value of this expression?
• What does this procedure do?
• Show the steps in evaluating this recursive procedure.
• Fill in the blanks to finish the definition.
• Write a procedure to do the following.
• Find the errors in the following procedure.

Sample Quiz Questions

There are enough of these that you should check the eboard.

Implement a procedure

Without using list-ref, write a procedure, (my-list-ref lst n), that extracts element n of a list. For example,

> (my-list-ref (list "red" "orange" "yellow" "green" "blue" "indigo" "violet") 5)
"indigo"
> (my-list-ref (list "red" "orange" "yellow" "green" "blue" "indigo" "violet") 0)
"red"

A Solution

• What is our base case?
• If we can solve the recursive case, how does that help us find the overall solution?
• How do we simplify/change the parameters for the recursive case.

• Check your answer!

  (define my-list-ref (lambda (lst n) (display (list 'my-list-ref lst n)) (newline) (if (zero? n) (car lst) (my-list-ref (cdr lst) (- n 1)))))

  (my-list-ref (list "red" "orange" "yellow" "green" "blue" "indigo" "violet") 0) (my-list-ref (red orange yellow green blue indigo violet) 0) "red" (my-list-ref (list "red" "orange" "yellow" "green" "blue" "indigo" "violet") 1) (my-list-ref (red orange yellow green blue indigo violet) 1) (my-list-ref (orange yellow green blue indigo violet) 0) "orange" (my-list-ref (list "red" "orange" "yellow" "green" "blue" "indigo" "violet") 5) (my-list-ref (red orange yellow green blue indigo violet) 5) (my-list-ref (orange yellow green blue indigo violet) 4) (my-list-ref (yellow green blue indigo violet) 3) (my-list-ref (green blue indigo violet) 2) (my-list-ref (blue indigo violet) 1) (my-list-ref (indigo violet) 0) "indigo"

Find the errors

Identify the errors in the following procedure, which is supposed to count the number of odd values in a list of integers.

(define tally-odd
  (lambda (lst)
    (tally-odd-kernel 0 lst)))

(define tally-odd-helper
  (lambda (lst tally)
    (cond
      [(null? lst)
       0]
      [(odd? (car lst))
       (+ 1 tally)]
      [else
       (tally-odd helper lst tally)])))

A Solution

• Name change from tally-odd-kernel to tally-odd-helper
• tally-odd helper should be tally-odd-helper.
• Parameters are in the wrong order.
• When the car is odd, we still need to recurse, so it should be (tally-odd-helper (cdr lst) (+ 1 tally)).
• For the else clause, we want the cdr of the list.
• The base case should probably be tally.

Show the steps

Consider the following procedure

(define fun
  (lambda (lst)
    (if (null? lst)
        0
        (- (car lst) (fun (cdr lst))))))

Show the steps in evaluating (fun '(1 2 3 4 5)). You need not show the evaluation of if, car, and cdr; just show the results. For example,

(fun '(1 2 3 4 5))
=> (- 1 (fun '(2 3 4 5)))

Show the steps

Consider the following procedure

(define fun
  (lambda (lst)
    (funner (cdr lst) (car lst))))

(define funner
  (lambda (lst val)
    (if (null? lst)
        val
        (funner (cdr lst) (- val (car lst))))))

Show the steps in evaluatng (fun '(1 2 3 4 5). You can immediately evaluate car, cdr, and if.

Complete the code

Finish the instructions for the tally-odd procedure below.

(define tally-odd
  (lambda (lst)
    (cond
      [(null? lst)
       _____]
      [(odd? (car lst))
       _____ (tally-odd (cdr lst))]
      [else
       _____ (tally-odd (cdr lst))])))

A solution

(define tally-odd
  (lambda (lst)
    (cond
      [(null? lst)
       0]
      [(odd? (car lst))
       (+ 1 (tally-odd (cdr lst)))]
      [else
       (tally-odd (cdr lst))])))

Would also accept the last line as the following. (But it's somewhat silly to add 0, it's just extra code and extra work.)

       (+ 0 (tally-odd (cdr lst)))])))

Document

Fill in the Six P's for the following procedure

(define whatzitdo
  (lambda (lst)
    (whatzitdotwo lst null)))

(define whatzitdotwo
  (lambda (lst val)
    (if (null? lst)
        val
        (whatzitdotwo (cdr lst) (cons (car lst) val)))))

Evaluate

Consider the following procedure

(define whatzitdo
  (lambda (lst)
    (whatzitdotwo lst null null)))

(define whatzitdotwo
  (lambda (lst foo bar)
    (if (null? lst)
        (list (reverse foo) (reverse bar))
        (whatzitdotwo (cdr lst)
                      (cons (car lst) bar)
                      foo))))

What is the value of (whatzitdo '(1 2 3 4 5))?

A Solution

(whatzitdo '(1 2 3 4 5))
=> (w2 '(1 2 3 4 5) '() '())
=> (w2 '(2 3 4 5) '(1) '())
=> (w2 '(3 4 5) '(2) '(1))
=> (w2 '(4 5) '(3 1) '(2))
=> (w2 '(5) '(4 2) '(3 1))
=> (w2 '() '(5 3 1) '(4 2))
=> '((1 3 5) (2 4))
; It split the list in half, using alternating positions!

Show steps

Consider the following procedure.

(define fun (lambda (a b) (if (> a b) null (cons a (fun (+ a 1) b)))))

Show the steps in evaluating (fun 5 9).

A Solution

(fun 5 9) (cons 5 (fun 6 9)) (cons 5 (cons 6 (fun 7 9))) (cons 5 (cons 6 (cons 7 (fun 8 9)))) (cons 5 (cons 6 (cons 7 (cons 8 (fun 9 9))))) (cons 5 (cons 6 (cons 7 (cons 8 (cons 9 (fun 10 9)))))) (cons 5 (cons 6 (cons 7 (cons 8 (cons 9 null))))) (cons 5 (cons 6 (cons 7 (cons 8 '(9))))) (cons 5 (cons 6 (cons 7 '(8 9)))) (cons 5 (cons 6 '(7 8 9)))) (cons 5 '(6 7 8 9)) '(5 6 7 8 9))

Evaluate

Consider the following procedure.

(define fun (lambda (a b) (if (> a b) null (cons a (fun (+ a 1) b)))))

What is the result of (fun -3 8)?

A Solution

'(-3 -2 -1 0 1 2 3 4 5 6 7 8)

Document

Document the following procedure, which takes two integers as input.

(define fun (lambda (a b) (if (> a b) null (cons a (fun (+ a 1) b)))))