;; 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-beginner-reader.ss" "lang")((modname reveiwsession) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ())))
;; Exam Review

;; #3 Fall 2010 Exam
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;S
(require 2htdp/image)
(define (prog str) (string-length str))

(cond [(< (prog "abcdef") 3) (circle 5 "solid" "blue")]
      [else (* 5 (+ 4 3))])

;; (string-length "abcdef"): plug in
;; (< 6 3) : arith
;; false : Conditional
;; (+ 4 3) : arith
;; (* 5 7): arith

;; #6 Fall 2010 Exam
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; A Plan is one of:
;; - ’arrive
;; - (make-forward Number Plan)
;; - (make-back Number Plan)
(define-struct forward (dist plan))
(define-struct back (dist plan))

#;(define (distance-template p)
    (cond [(and (symbol? p) (symbol=? p 'arrive))
           ...]
          [(forward? p) (... (forward-dist p)
                             (distance-template (forward-plan p)))]
          [else (... (back-dist p)
                     (distance-template (back-plan p)))]))

;; distance: Plan -> Number
;; Computes the net distance of a Plan.
;; Examples: (distance 'arrive) = 0
;; (distance (make-forward 10 'arrive)) = 10
;; (distance (make-back 5 (make-forward 10 'arrive)) = 5
(define (distance p) 
  (cond [(and (symbol? p) (symbol=? p 'arrive)) 0]
        [(forward? p) (+ (forward-dist p)
                         (distance (forward-plan p)))]
        [else (- (distance (back-plan p)) (back-dist p))]))

(check-expect (distance 'arrive) 0)
(check-expect (distance (make-forward 10 'arrive)) 10)
(check-expect (distance (make-back 10 'arrive)) -10)
(check-expect (distance (make-back 5 (make-forward 10 'arrive))) 5)
(check-expect (distance (make-forward 5 (make-back 10 'arrive))) -5)

;; Types of Data Definitions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Atomic Data: 5, false, "Hello World" 'hello
;; Structures: (define-struct a (b c))
;; Enumeration: A Light is oneof: 'red 'green 'yellow
;; Recursive Union: 
;; A DOH is oneof:
;; (make-bart Symbol boolean)
;; (make-homer DOH String)
(define-struct bart (wants gets))
(define-struct homer (says times))

#;(define (doh-temp d)
    (cond [(bart? d) (... (bart-wants d)
                          (bart-gets d))]
          [else (... (doh-temp (homer-says d))
                     (homer-times d))]))

;; Template for #4 2009
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; A Rev is one of: ’A, ’B, ’C, ’D, ’F

(define-struct paper (title rev1 rev2 rev3))
;; A Paper is a (make-paper String Rev Rev Rev)

;; A LoP is one of:
;; - empty
;; - (cons Paper LoP)

#;(define (paper-template p)
    (... (paper-title p)
         (paper-rev1 p)
         (paper-rev2 p)
         (paper-rev3 p)))

#;(define (lop-temp p)
    (cond [(empty? p) ...]
          [else (... (paper-template (first p))
                     (lop-temp (rest p)))]))

;; good-papers: LoP -> LoP
;; Create a list of papers, all of which have at least one 'A review.
;; Examples: (good-papers empty) = empty
;; (good-papers (list (make-paper "Hello World" 'F 'B 'B)
;;                    (make-paper "Whale Biology" 'A 'C 'B)))
;; = (list (make-paper "Whale Biology" 'A 'C 'B))
(define (good-papers lop)
  (cond [(empty? lop) empty]
        [(has-A? (first lop))
         (cons (first lop)
               (good-papers (rest lop)))]
        [else (good-papers (rest lop))]))

(check-expect (good-papers empty) empty)
(check-expect (good-papers (list (make-paper "Hello World" 'F 'B 'B)
                                 (make-paper "Whale Biology" 'A 'C 'B)))
              (list (make-paper "Whale Biology" 'A 'C 'B)))

;; has-A?: Paper -> boolean
;; does the paper contain 'A review?
;; Examples: (has-A? (make-paper "Hello World" 'F 'B 'B)) = false
;; (has-A? (make-paper "Whale Biology" 'A 'C 'B)) = true
(define (has-A? p)
  (or (symbol=? 'A (paper-rev1 p))
      (symbol=? 'A (paper-rev2 p))
      (symbol=? 'A (paper-rev3 p))))

(check-expect (has-A? (make-paper "Hello World" 'F 'B 'B)) false)
(check-expect (has-A? (make-paper "Whale Biology" 'A 'C 'B)) true)

;; #2 Exam 2010
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; A ShoeKind is one of:
;; - ’Walking
;; - ’Running
;; - ’Sk8ing

;; Enumeration

#;(define (shoe-temp s)
    (cond [(symbol=? s 'Walking) ...]
          [(symbol=? s 'Running) ...]
          [(symbol=? s 'Sk8ing) ...]))

;; #4 Exam 2010
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; A Student is:
;; - (make-student String Number Number Number)
(define-struct student (name exam1 exam2 hw))
;; Each of the numbers is a percentage from 0 to 100

(define (student-temp s)
  (... (student-name s)
       (student-exam1 s)
       (student-exam2 s)
       (student-hw s)))

;; A LoS is one of:
;; - empty
;; - (cons Student LoS)

#;(define (los-temp l)
    (cond [(empty? l) ...]
          [else (... (student-template (first l))
                     (los-temp (rest l)))]))

;; top-students: LoS -> LoS
;; makes a list of all the students, whose grades are 90% or greater
;; Examples: (top-students empty) = empty
;; (top-students (list james
;;                     (make-student "Josh" 100 98 90)))
;; = (list (make-student "Josh" 100 98 90))
(define (top-students los)
  (cond [(empty? los) empty]
        [(above-90? (first los))
         (cons (first los)
               (top-students (rest los)))]
        [else (top-students (rest los))]))
(define james (make-student "James" 50 50 50))
(define josh (make-student "Josh" 100 98 90))
(check-expect (top-students (list james josh))
              (list josh))
(check-expect (top-students empty) empty)

;; above-90?: Student -> boolean
;; are all three of the student's grades above 90?
(define (above-90? s)
  (and (>= (student-exam1 s) 90)
       (>= (student-exam2 s) 90)
       (>= (student-hw s) 90)))

(check-expect (above-90? (make-student "James" 50 50 50)) false)
(check-expect (above-90? (make-student "Josh" 100 98 90)) true)


;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;   ;;;;;  ;;;;;                                                                       
;     ;      ;                                                                         
;     ;      ;                                                                         
;     ;      ;       ;;;;;      ;;;  ;;;         ;;;;;       ;;;   ;;;       ;;;;; ;   
;     ;      ;      ;     ;       ;;;   ;       ;     ;        ; ;;   ;     ;     ;;   
;     ;      ;     ;       ;      ;      ;     ;       ;       ;;     ;     ;      ;   
;     ;;;;;;;;    ;         ;     ;      ;    ;         ;      ;            ;          
;     ;      ;    ;         ;     ;      ;    ;         ;      ;             ;;;;;     
;     ;      ;    ;         ;     ;      ;    ;         ;      ;                  ;    
;     ;      ;    ;         ;     ;      ;    ;         ;      ;                   ;   
;     ;      ;    ;         ;     ;      ;    ;         ;      ;                   ;   
;     ;      ;     ;       ;      ;      ;     ;       ;       ;           ;       ;   
;     ;      ;      ;     ;       ;      ;      ;     ;        ;           ;;     ;    
;   ;;;;;  ;;;;;     ;;;;;      ;;;;;  ;;;;;     ;;;;;       ;;;;;;;;      ; ;;;;;     
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      
;                                                                                      

;; A Mobile is one of:
;; - Number
;; - (make-rod Mobile Mobile)
(define-struct rod (left right))

#;(define (mobile-temp m)
    (cond [(number? m) ...]
          [else (... (mobile-temp (rod-left m))
                     (mobile-temp (rod-right m)))]))

;; balanced?: Mobile -> boolean
;; is the mobile balanced?
(define (balanced? m)
  (cond [(number? m) true]
        [else (and (= (find-weight (rod-left m))
                      (find-weight (rod-right m)))
                   (balanced? (rod-left m))
                   (balanced? (rod-right m)))]))

(check-expect (balanced? 15) true)
(check-expect (balanced? (make-rod 15 15)) true)
(check-expect (balanced? (make-rod 15 (make-rod 7.5 7.5)))
              true)
(check-expect (balanced? (make-rod 15 (make-rod 5 10))) false)
(check-expect (balanced? (make-rod 15 7.5)) false)
(check-expect (balanced? (make-rod (make-rod 5 10) (make-rod 5 10)))
              false)

;; find-weight: Mobile -> number
;; finds the weight of a mobile
(define (find-weight m)
  (cond [(number? m) m]
        [else (+ (find-weight (rod-left m))
                 (find-weight (rod-right m)))]))

;; # 4 Honors 2010
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; mobile-swap: Mobile -> Mobile
;; creates a mirror image of the given mobile
(define (mobile-swap m)
  (cond [(number? m) m]
        [else (make-rod (mobile-swap (rod-right m))
                        (mobile-swap (rod-left m)))]))

(check-expect (mobile-swap (make-rod 10 5)) (make-rod 5 10))
(check-expect (mobile-swap (make-rod (make-rod 10 5) (make-rod 7 3)))
              (make-rod (make-rod 3 7) (make-rod 5 10)))


;; Extra Credit #1 exam 2010
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; to-binary: Number -> Lob
;; convert a number to a Binary List
;; 13 = (cons 1 (cons 1 (cons 0 (cons 1 empty)))
;; 0 = empty
(define (to-binary n)
  (reverse (helper-function n)))

;; helper-function: Number -> LOB
;; convert a number to a reversed Binary List
(define (helper-function n)
  (cond [(or (= n 1) (= n 0))
         (cons n empty)]
        [else (cons (remainder n 2)
                    (helper-function (quotient n 2)))]))

(check-expect (to-binary 13) (cons 1 (cons 1 (cons 0 (cons 1 empty)))))
(check-expect (to-binary 0) (cons 0 empty))

;; #1 Exam 2010
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(define s (make-student "Mr. Smarty" 90 100 97))
(define m (make-student "Ms. Middle" 64 72 68))
(define h (make-student "Dr. Hopeless" 43 52 35))

;; above-average-90?: Student -> boolean
;; are all three of the student's grades above 90?
(define (above-average-90? s)
  (>= (+ (* .3 (student-exam1 s))
         (* .3 (student-exam2 s))
         (* .25 (student-hw s))
         15)
      90))

(check-expect (above-average-90? s) true)
(check-expect (above-average-90? m) false)
(check-expect (above-average-90? h) false)


;; Extra Credit Exam 2009
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; A BT (binary tree) is one of:
;; - Number
;; - (make-node BT BT)
(define-struct node (left right))
;; A LoN is one of:
;; - empty
;; - (cons Number LoN)

;; flatten: BT -> LON
;; flattens a binary search tree
(define (flatten bt)
  (cond [(number? bt) (list bt)]
        [else (append (flatten (node-left bt))
                      (flatten (node-right bt)))]))

(check-expect (flatten 7) (cons 7 empty))
(check-expect (flatten (make-node (make-node 3 4)
                                  (make-node 7 4)))
              (cons 3 (cons 4 (cons 7 (cons 4 empty)))))
(check-expect (flatten (make-node 8
                                  (make-node (make-node 2 1)
                                             7)))
              (cons 8 (cons 2 (cons 1 (cons 7 empty)))))