;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-advanced-reader.ss" "lang")((modname ps7) (read-case-sensitive #t) (teachpacks ((lib "image.ss" "teachpack" "htdp"))) (htdp-settings #(#t constructor repeating-decimal #t #t none #f ((lib "image.ss" "teachpack" "htdp")))))
;                                                                                             
;                                                                                             
;                                                                                             
;   ;;;;                          ;        ;             ;          ;;;              ;        
;   ;   ;                         ;        ;             ;         ;   ;             ;        
;   ;   ;                                  ;             ;         ;   ;             ;        
;   ;   ;  ; ;;    ;;;   ;   ;    ;     ;;;;   ;;;    ;;;;         ;       ;;;    ;;;;   ;;;  
;   ;;;;   ;;  ;  ;   ;  ;   ;    ;    ;   ;  ;   ;  ;   ;         ;      ;   ;  ;   ;  ;   ; 
;   ;      ;   ;  ;   ;   ; ;     ;    ;   ;  ;;;;;  ;   ;         ;      ;   ;  ;   ;  ;;;;; 
;   ;      ;      ;   ;   ; ;     ;    ;   ;  ;      ;   ;         ;      ;   ;  ;   ;  ;     
;   ;      ;      ;   ;    ;      ;    ;   ;  ;   ;  ;   ;         ;   ;  ;   ;  ;   ;  ;   ; 
;   ;      ;       ;;;     ;      ;     ;;;;   ;;;    ;;;;          ;;;    ;;;    ;;;;   ;;;  
;                                                                                             
;                                                                                             
;                                                                                             

;; Question #1  - structure definitions and an example descendant tree


; a family-tree is:
;   (make-parent list-of-family-tree symbol number symbol)
(define-struct parent (children name date eyes))

; Youngest Generation:
(define Gustav (make-parent empty 'Gustav 1988 'brown))

(define Fred&Eva (list Gustav))

; Middle Generation:
(define Adam (make-parent empty 'Adam 1950 'yellow))
(define Dave (make-parent empty 'Dave 1955 'black))
(define Eva (make-parent Fred&Eva 'Eva 1965 'blue))
(define Fred (make-parent Fred&Eva 'Fred 1966 'pink))

(define Carl&Bettina (list Adam Dave Eva))

; Oldest Generation:
(define Carl (make-parent Carl&Bettina 'Carl 1926 'green))
(define Bettina (make-parent Carl&Bettina 'Bettina 1926 'green))


;; Question #2

; an answer is either
; - 'too-low
; - 'just-right
; - 'too-high

; make-uniform-secret : integer integer -> secret
; Chooses a secret between `low' and `high' (inclusive) uniformly 
; at random and returns a function that lets you guess the secret.
(define (make-uniform-secret low high)
  (local [(define secret (uniform-between low high))]
    (lambda (guess)
      (check-guess guess secret))))

; make-special-secret : integer integer -> (integer -> answer)
; Like `make-uniform-secret' but chooses `low' with probability .2,
; `high' with probability .2, and uniformly among the rest.
(define (make-special-secret low high)
  (local [(define r (random))
          (define secret
            (cond [(< r .2) low]
                  [(< r .4) high]
                  [else (uniform-between (+ 1 low) (- high 1))]))]
    (lambda (guess)
      (check-guess guess secret))))

; check-guess : integer integer -> answer
; Checks a guess against a given secret
(define (check-guess guess secret)
  (cond
    [(< guess secret) 'too-low]
    [(= guess secret) 'just-right]
    [(> guess secret) 'too-high]))

(check-expect (check-guess 1 2) 'too-low)
(check-expect (check-guess 2 2) 'just-right)
(check-expect (check-guess 3 2) 'too-high)

; uniform-between : integer integer -> integer
; Chooses a random integer between `low' and `high' uniformly at random
(define (uniform-between low high)
  (+ low (random (+ 1 (- high low)))))

; sample-average : (-> number) natural-number -> number
; Runs a randomized function `f' `n' times and returns the average of those runs
(define (sample-average f n)
  (/ (sample-sum f n) n))

; sample-sum : (-> number) natural-number -> number
; Runs a randomized function `f' `n' times and returns the sum of those runs
(define (sample-sum f n)
  ; Need an accumulator-based definition to go beyond a few million runs
  (cond [(zero? n) 0]
        [else (+ (f) (sample-sum f (- n 1)))]))

(check-within 
 (sample-average (lambda () (uniform-between 2 4)) 100000)
 3
 .1)

; a guess-result is
; (make-guess-result integer natural-number)
(define-struct guess-result (secret guesses))

; run-game : integer integer secret-maker natural-number guesser -> numbers
; where secret-maker = (integer integer -> (integer -> answer))
;   and guesser = (integer -> answer) integer integer -> guess-result
; Plays guessing game `runs' times, using `make-secret' with bounds `low' and `high'
; to choose the secret and `guess-secret' to guess it.
; Returns the average number of attempts that `guess-secret' needed.
(define (run-game low high make-secret runs guess-secret)
  (sample-average
   (lambda ()
     (guess-result-guesses 
      (guess-secret (make-secret low high) low high)))
   runs))

; guess-with-linear-search : (integer -> answer) integer integer -> guess-result
; Guesses a secret using linear search.
(define (guess-with-linear-search secret low high)
  (local [(define answer (secret low))]
    (cond [(symbol=? answer 'just-right)
           (make-guess-result low 1)]
          [(symbol=? answer 'too-low)
           (increment-guesses
            (guess-with-linear-search secret (+ low 1) high))])))

; increment-guesses : guess-result -> guess-result
; Increments guesses
(define (increment-guesses r)
  (make-guess-result (guess-result-secret r)
                     (+ 1 (guess-result-guesses r))))


(check-within
 (run-game 1 100 make-uniform-secret 1000 guess-with-linear-search)
 50
 3)

(check-within
 (run-game 1 100 make-special-secret 1000 guess-with-linear-search)
 50
 3)