University of California, Berkeley
EECS Department - Computer Science Division

CS3 Lecture 4 : Words, Sentences, True and False

---

Overview of today's lecture

• Answers to questions that have come up
• Review
• Words and Sentences
  • Introduction
  • Selectors
  • Constructors
• True and False
  • Introduction
  • Predicates
  • Combining predicates with and, not and or
  • If : How we make decisions...
  • cond: Writing conditionals
  • cond Example: Crossing an intersection
• Next Time
• Puzzle : Toggling Frogs
• Game : Fair Shares and Uneven Pairs
• References

---

Answers to questions that have come up

• Why won't I have the same TA every week?
  • We're implementing a system known as Buddy TAing, wherein TAs choose a buddy to work with and teach each others' discussions every other week.
  • It allows us to provide better instruction since the TAs can spend two weeks preparing instead of the usual one.
  • They also get weekly feedback from the "observer TA" (the TA who has the week off), which is really helpful for them.
  • As of right now, not all TA schedules allow for Buddy TAing.
• How do I do the newsgroup again?
  • Click on the CS3 homepage top Newsgroup link which takes you to ucb.class.cs3

Review

• expressions are simple or compound (function argument1 argument2 ...), we learned how they are evaluated.
• functions: we showed you how to define your own functions, what power you have!

---

Words and Sentences

Introduction

• We need to be more formal about words and sentences and get away from numbers for a while.
• We can ask for the value of an expression by just asking for it:
• But what if I don't want to evaluate it, but just take it literally? The answer: quote
• We use an abbreviation for it since we use it so much: ' (called quote)
• Word: A sequence of characters, including letters, digits or punctuations. Numbers are a special case of words.
• Sentences: A bunch of words enclosed in parenthesis

Selectors

• There are several selectors, or functions that take apart data types (in this case words and sentences)

• Predict what would result from interactions (see other sheet)
• There is no data type such as "character"; a letter is the same as a one-letter word
• We can define others based on these!

(define (second word-or-sentence)
   (first (butfirst word-or-sentence)))

(define (but-first-two word-or-sentence)
   (butfirst (butfirst word-or-sentence)))

Constructors

• There are two constructors, or functions that put together data types (in this case words and sentences)

• It's probably a good idea to play around with these constructors and selectors so they make more sense to you.
• Predict what would result from interactions (see other sheet)

---

True and False

Introduction

• We need to give Scheme the ability to make decisions, to branch at a fork in the logical road.
• E.g., If the Giants win, celebrate. If the Giants lose, say "we'll get them next year"
• We need to show you
  • Predicates. These are functions that take input and return true (#t) or false (#f), boolean values
  • We need special forms such as if and cond which allow us to do one thing or another

Predicates

• Functions that return true #t or false #f values
• Examples with numbers (iff stands for if and only if)
  • (< num1 num2 ... numN) ;; true iff num1 < num2 < ... < numN
  • (> num1 num2 ... numN) ;; true iff num1 > num2 > ... > numN
  • (= num1 num2 ... numN) ;; true iff num1 = num2 = ... = numN
  • (<= num1 num2 ... numN) ;; true iff num1 <= num2 <= ... <= numN
  • (>= num1 num2 ... numN) ;; true iff num1 >= num2 >= ... >= numN
  • (integer? num) ;; true iff num is an integer
  • (zero? num) ;; true iff num is zero
  • (even? num) ;; true iff num is an even number
  • (odd? num) ;; true iff num is an odd number
  • (number? num) ;; true iff num1 is a number (integer, real or ratio)
• Examples with Words and Sentences
  • (before? arg1 arg2) ;; Does the first argument come alphabetically before the second?
  • (empty? arg) ;; Is arg empty, i.e., the empty word "" or the empty sentence ()?
  • (equal? arg1 arg2) ;; Are the two arguments the same thing?
  • (member? arg1 arg2) ;; Is the first argument an element of the second?
  • (sentence? arg) ;; Is the argument a sentence?
  • (word? arg1) ;; Is the argument a word? (Note: numbers are words)
• Examples with true and false
• (boolean? arg) ;; Returns true if arg is a boolean (#t or #f)
• Everything that isn't False is True
  • "#t isn't the only true value. In fact, every value is considered true except for #f" -- Simply Scheme

Combining predicates with and, not and or

• Usage: (and test1 test2 ... testN)
  • Evaluates clauses left to right.
  • If a clause evals to false, return #f.
  • Otherwise (all clauses are true) return the result of the final clause.
• Usage: (or test1 test2 ... testN)
  • Evaluates clauses left to right.
  • If a clause evals to not-false, its value is returned.
  • Otherwise (all clauses are false) return #f.
• Usage: (not test)
  • Returns #t if test is false, and returns #f otherwise.
• Review of Boolean logic with examples

• and & or are special forms: not all of their arguments may be evaluated -- this is called short-circuit evaluation.
• and/or Example: Test if a number is between 0 and 100

If : How we make decisions...

• Usage: (if condition action else-action)
  • Special form! (the actions are only evaluated depending on the condition)
  • I.e., only one of the actions is evaluated (thus making if a special form)
  • If condition is not false, do action otherwise do else-action
• If the condition is false and there is no else-action, an #[undefined] value is returned.
• Let's look at a simple example about division with if (on sheet)
• If is composable
  • Even though it's a special form, if returns values just like another function, so it can be composed. See example.

cond: Writing conditionals

• What if you wanted to test among a series of things?

(define (get-cs3-grade score)
   (if (> score 390)
       'A+
       (if (> score 370)
           'A
           (if (> score 360)
               'A-
               'Did-not-get-an-A))))

• You can imagine if there were lots of different grades, this would get really long
• General form of cond

(cond (cond1 actions1 ... )
      (cond2 actions2 ... )
               ...
      (condN actionsN ... )
      (else  else-actions ... ))

• Cond evaluation rules:
  • Evaluate conditions in sequence until one returns true value then evaluate its actions and return the last one
  • else condition is fallout case - always true
  • If all conditions are false (and there is no else clause), return value is #[undefined]
• Comments:
  • Watch out with parentheses
  • Each cond/actions pair must be in parens.
  • Conditions and actions that are function calls are in parens so you get the double paren as in (cond ((odd? ...
• Looking at the original grade program:

(define (get-cs3-grade score)
   (cond ((> score 390) 'A+)
         ((> score 370) 'A )
         ((> score 360) 'A-)
         (else 'Did-not-get-an-A)))

• Why don't we need the following?

(define (get-cs3-grade score)
   (cond ((> score 390) 'A+)
         ((and (<= score 390) (> score 370)) 'A )
         ((and (<= score 370) (> score 360)) 'A-)
         (else 'Did-not-get-an-A)))

• Because in order to get to the second line, we know the score is not greater than 390, so the test is redundant!

cond Example: Crossing an intersection

: (define (walk light city cops-present)
    (cond ((equal? city 'berkeley) 'strut)
          ((equal? light 'green) 'go)
          ((equal? light 'not-working) 'go-if-clear)
          ((and (equal? light 'flashing-red)
                 cops-present) 'wait)
          ((equal? light 'flashing-red) 'hurry)
          ((equal? light 'purple) 'stop-drinking)
          (else 'go-to-sleep)))
walk

: (walk 'green 'berkeley #t)
==> strut

: (walk 'green 'sf #t)
==> go

: (walk 'not-working 'sf #t)
==> go-if-clear

: (walk 'flashing-red 'sf #t)
==> wait

: (walk 'flashing-red 'sf #f)
==> hurry

: (walk 'purple 'sf #t)
==> stop-drinking

: (walk 'i-am-tired 'sf #t)
==> go-to-sleep

Summary

• Today's big ideas: new data types words, sentences and booleans
  • Lots of new functions and ideas. Practice, practice, practice.
• Smaller ideas: special forms, short-circuit evaluation, branching, lots of expressive power!

Next Time

• We'll look at variables

Puzzle : Toggling frogs

• You have 100 lightbulbs, numbered 1-100, and 100 frogs, also numbered 1-100.
• Whenever a frog jumps on a lightbulb, it toggles between on and off. All lightbulbs are initially off.
  • frog #1 jumps on every lightbulb (ie turning them all on).
  • frog #2 jumps on every 2nd lightbulb, toggling some of them back off.
  • ...
  • frog #k jumps on every kth lightbulb.
• After 100 frogs, which ones are on?

Game : Fair shares and uneven pairs [BerlekampConwayGuy82]

• Take up to 10 almonds and arrange them into heaps onto the carpet - we suggest you start with lots of 1s and 2s
• Then challenge a guest to the game with the following two moves
  • Divide any heap into two or more equal-sized heaps
  • Unite any two heaps of different sizes
• You win by completely separating the almonds (into heaps of size 1) after which your opponent has no legal move.
• There's always at least one move from any other position, e.g., to shatter some heaps into heaps of size 1

References

• [BerlekampConwayGuy82] Elwyn Berlekamp, John H. Conway, Richard K. Guy "Winning Ways for Your Mathematical Plays", Academic Press, London, 1982.

WWW Maven: Dan Garcia (ddgarcia@cs.berkeley.edu) Send me feedback