Approximate overview
(define play-seven-eleven
(lambda ()
(cond
[(= 7 (pair-a-dice))
1]
[(= 11 (pair-a-dice))
1]
[else
0])))
(define pair-a-dice
(lambda ()
(+ (roll-a-die) (roll-a-die))))
(define roll-a-die
(lambda ()
(random 1 7)))
(define count-wins
(lambda (n)
(cond
; No games -> No wins
[(zero? n)
0]
; We win (-: Count it and move on
[(= (play-seven-eleven) 1)
(+ 1 (count-wins (- n 1)))]
; We lose )-: Just move on
[(= (play-seven-eleven) 0)
(count-wins (- n 1))]
; ??? This should never happen
[else
(error "Tie!")])))
(play-seven-eleven) returns 0 or 1, so we should never reach
the else case. What’s going wrong?Hypotheses
(define count-wins
(lambda (n)
(cond
; No games -> No wins
[(zero? n)
0]
; We win (-: Count it and move on
[(= (play-seven-eleven) 1)
(+ 1 (count-wins (- n 1)))]
; We lose )-: Just move on
[else
(count-wins (- n 1))])))
(define count-wins
(lambda (n)
(if (zero? n)
0
(+ (play-seven-eleven)
(count-wins (- n 1))))))
8/36 rolls win. So when we play a lot of games, we should win about 8/36 of the time. If we play 3600 games, we should win approximately 800 times. Do we? Nope.
Fix.
random neither too few nor too many times.pair-a-dice is one of the best procedure names ever.;;; (random-list-element lst) -> any?
;;; lst : listof any?
;;; Randomly select an element of `lst`
(define random-list-element
(lambda (lst)
(list-ref lst (random (length lst)))))
;;; people -> listof string?
;;; A list of some of the folks who teach 151
(define people (list "Peter-Michael" "Nicole" "Sarah" "SamR" "Barbara" "Priscilla" "Jerod"))
;;; (random-person) -> string?
;;; Randomly select an element of the people list.
(define random-person
(lambda ()
(random-list-element people)))
Why does random-person have a lambda with no parameters?
Couldn’t we just use
(define random-person
(random-list-element people))
Without the
lambda, it evaluates therandom-list-elementonce, so we won’t get different strings.
Procedures run their body each time you call them, permitting different behavior with randomness.
Our goal: Generate some interesting language (Haiku and Templated Writing).
Consider the following procedures
;;; (vowel? char) -> boolean
;;; char : char?
;;; Determine if char is a vowel.
(define vowel?
(let ([vowels (string->list "aeiou")])
(lambda (ch)
(integer? (index-of vowels (char-downcase ch))))))
;;; (count-vowels str) -> integer?
;;; str : string?
;;; Count the number of vowels in str
(define count-vowels
(lambda (str)
(tally vowel? (string->list str))))
;;; (select-special-words words) -> list-of string?
;;; words : list-of string?
;;; Selects all the special words in words using the ALTV criterion.
(define select-special-words
(lambda (words)
(filter (o (section > <> 2) count-vowels) words)))
> (select-special-words '("uh" "happy" "bob" "sad" "uh" "chemistry" "galaxy" "galaxian" "shoe"
"um" "microphone"))
'("galaxian" "microphone")
> (select-special-words '("um" "position" "uh" "mumble" "evaluate"))
'("position" "evaluate")
a. What kinds of words does select-special-words select?
Words with more than two vowels.
ALTV = At Least Three Vowels
b. Explain how (o (section > <> 2) count-vowels) works as a
predicate for such words.
tallyuses this to check each element in the list to see if it has more than two vowels.
The meaning of the composition is “apply count vowels, then apply the section”, the section is “thing greater than two”.
(o f g)is a shorthand for(lambda (x) (f (g x)))
c. Rewrite vowel? using section and composition but no
lambda.
(define vowel?
(let ([vowels (string->list "aeiou")])
(lambda (ch)
(integer? (index-of vowels (char-downcase ch))))))
Hint: Think about the order in which we do things in this procedure.
(define vowel?
(let ([vowels (string->list "aeiou")])
(o integer? (section index-of vowels <>) char-downcase)))
You are unlikely to receive a problem this hard.
Consider the following procedure.
(define silly
(lambda (lst)
(map (lambda (x) (sqr (+ 1 x)))
(filter odd? lst))))
Rewrite the procedure using o and section so that it has no lambdas.
o) and filling in parameters
(with section).(lambda (x) (sqr (+ 1 x))) is “a procedure that takes one parameter,
adds 1, then squares. “add 1” is (section + 1 <>). So “add 1 then
square” is (o sqr (section + 1 <>)).silly first filters all the odd elements, then maps that add-then-square.
(section filter odd? <>)(section map procedure <>)(define silly
(o (section map (o sqr (section + 1 <>)) <>)
(section filter odd? <>)))