Overview

• Random administrivia
• You ask questions, I attempt to answer.
• We talk about the forthcoming quiz.

Random Administrivia

Will there be more than one section on 161 next semester?

No.

Can we take 207 without taking 161?

No.

Can we take 161 and 207 simultaneously?

No.

So what should I do if I want to continue in CS but can't take 161 next semester?

Ambitious students teach themselves 161 over the summer using the old curriculum. Talk to me separately about how.

Slightly less ambitious students might talk to the people who are teaching conflicting classes about removing the conflict.

Your Questions

Can we do some tricky questions to get ready for the quiz?

What does the following procedure do on an input of '(1 2 3 4 5 6)?

    (define tricky
      (lambda (lst)
        (let kernel ([left null]
                     [right null]
                     [remaining lst])
           (if (null? remaining)
               (list left right)
               (kernel right 
                       (cons (car remaining) left)
                       (cdr remaining))))))

One attempt to solve

    left    right   remaining
    ()      ()      '(1 2 3 4 5 6)
    ()      '(1)    '(2 3 4 5 6)
    '(1)    '(2)    '(3 4 5 6)
    '(2)    '(3 1)  '(4 5 6)
    '(3 1)  '(4 2)  '(5 6)
    '(4 2)  '(5 3 1)'(6)
    '(5 3 1)'(6 4 2)'()

Result

    '((5 3 1) (6 4 2))

We might make the base case (list (reverse left) (reverse right))

    '((1 3 5) (2 4 6))

What image do you get from the following?

    > (define world (image-show (image-new 200 200)))
    > (define t (turtle-new world))
    > (turtle-teleport! t 100 100)
    > (turtle-face! t 0)
    > (repeat 5 (lambda (turtle)
                  (turtle-forward! turtle 50)
                  (turtle-turn! turtle 144)))

Write an expression to have a turtle make a regular six-sided star using turtle graphics. You may choose to do two overlapping equilateral triangles or you may choose to just do the outline.

    (define world (image-show (image-new 200 200)))
    (define t (turtle-new world))
    (turtle-teleport! t 100 100)
    (turtle-face! t 0)
    (repeat 6 (lambda ()
                (turtle-forward! t 50)
                (turtle-turn! t -60)
                (turtle-forward! t 50)
                (turtle-turn! t 120)))

Using letrec for the kernel, write a procedure to find the ratio of even to odd numbers in a list of integers. Do ratios using division.

    (define even-to-odd
      (letrec ([kernel (lambda (evens odds remaining)
                         (if (null? remaining)
                             _________________ ; a
                             (let ([val (car remaining)])
                               (if (even? val)
                                   _________________ ; b
                                    _________________))))]) ; c
         (lambda (lst)
           (kernel 0 0 lst))))

One solution

    a. (/ evens odds)
    b. (kernel (+ 1 evens) odds (cdr remaining))
    c. (kernel evens (+ 1 odds) (cdr remaining))

Given that solution, what would a husk that catches inappropriate inputs look like?

         (lambda (lst)
           (cond
             [(not (list? lst))
              (error "even-to-odd: expects a list as its parameter, given" lst)]
             [(not (all integer? lst))
              (error "even-to-odd: expects a list OF INTEGERS as its parameter, given" lst)]
             ...
             [else
              (kernel 0 0 lst)]))))

Where is the turtle facing after the following expressions?

    (turtle-face! t 0)
    (for-each (lambda (x)
                (turtle-forward! t 10)
                (turtle-turn! t (* 15 x)))
              (iota 5))

What is the default size of each brush?

I don't know. It depends on the brush. If the brushes start with a "2. ", you can set their size. Otherwise, it's whatever the brush designer decided on.

How is all defined?

    (define all
      (lambda (pred? lst)
        (or (null? lst)
            (and (pred? (car lst))
                 (all pred? (cdr lst))))))

Or maybe

    (define all
      (lambda (pred? lst)
        (let kernel? ([l lst])
          (or (null? l)
              (and (pred? (car l))
                   (kernel? (cdr l)))))))

About the Quiz

Main topics:

• Local bindings of recursive procedures
  • letrec
  • Named let
• Turtle graphics
• repeat
• for-each
• Maybe a combination, but probably not.

Local bindings?

• Write a husk and kernel (e.g., "Write tally-odds so that the thing that does the tallying doesn't crash if the caller gives it someting other than a list of integers.")
• Explain what the following code does.

Turtles

• Sketch the result of the following call
• Write code to generate the following image (pictured or displayed)
• Where will the turtle be and what direction will it be facing after these commands?

Repetition with repeat and for each

• Read this code and explain it
• Perhaps incorporated into turtles, perhaps separate