;; 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-abbr-reader.ss" "lang")((modname lec8) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f ())))
;; list-of-num is either
;;   - empty
;;   - (cons num list-of-num)

;; large-fish : list-of-num -> list-of-num
;;  To keep only fish that are >= 5 lbs
;(define (large-fish lon)
;  (cond
;    [(empty? lon) ...]
;    [(cons? lon) 
;     ... (first lon)
;     ... (large-fish (rest lon)) ...]))
(define (large-fish lon)
  (cond
    [(empty? lon) empty]
    [(cons? lon) 
     (cond
       [(>= (first lon) 5)  (cons (first lon)
                                  (large-fish (rest lon)))]
       [else (large-fish (rest lon))])]))

(check-expect (large-fish empty) empty)
(check-expect (large-fish (cons 4 empty))
              empty)
(check-expect (large-fish (cons 7 empty))
              (cons 7 empty))
(check-expect (large-fish (cons 4 (cons 7 empty)))
              (cons 7 empty))
(check-expect (large-fish (cons 7 (cons 4 empty)))
              (cons 7 empty))


;; ----------------------------------------

;; A list-of-posn is either
;;   - empty
;;   - (cons posn list-of-posn)

;; A posn is
;;   (make-posn num num)

;; flip-posns : list-of-posn -> list-of-posn
;;  To flip every posn over the diagonal
(define (flip-posns lop)
  (cond
    [(empty? lop) empty]
    [(cons? lop)
     (cons (flip-posn (first lop))
           (flip-posns (rest lop)))]))

;; flip-posn : posn -> posn
(define (flip-posn p)
  (make-posn (posn-y p) (posn-x p)))


(check-expect (flip-posns empty) empty)
(check-expect (flip-posns (cons (make-posn 6 5) empty))
              (cons (make-posn 5 6) empty))
(check-expect (flip-posns (cons (make-posn 8 6)
                                (cons (make-posn 25 2)
                                      empty)))
              (cons (make-posn 6 8)
                    (cons (make-posn 2 25)
                          empty)))
;; ----------------------------------------

;; A list-of-grade is either
;;   - empty
;;   - (cons grade list-of-grade)

;; A grade is either
;;   - num
;;   - empty

;; all-passed? : list-of-grade -> boolean
;;   To determines whether all grades in log are passing
;(define (all-passed? log)
;  (cond
;    [(empty? log) ...]
;    [(cons? log) ...
;     (passed? (first log))
;     ... (all-passed? (rest log)) ...]))
(define (all-passed? log)
  (cond
    [(empty? log) true]
    [(cons? log)
     (and (passed? (first log))
          (all-passed? (rest log)))]))

;; passed? : grade -> boolean
(define (passed? n)
  (cond
    [(number? n) (>= n 70)]
    [(empty? n) false]))

(check-expect (all-passed? empty) true)
(check-expect (all-passed? (cons 100 (cons 0 (cons empty empty))))
              false)
(check-expect (all-passed? (cons 100 empty)) true)
(check-expect (all-passed? (cons empty empty))
              false)

;; ----------------------------------------

;; A list-of-lon is eiter
;;  - empty
;;  - (cons list-of-num list-of-lon)

;; list-of-num is either
;;   - empty
;;   - (cons num list-of-num)

;; sums : list-of-lon -> list-of-num
;;  To sum all the lists in lolon
(define (sums lolon)
  (cond
    [(empty? lolon) empty]
    [(cons? lolon)
     (cons (sum (first lolon))
           (sums (rest lolon)))]))

;; sum: list-of-num -> num
;;  To add up the numbers in lon
(define (sum lon)
  (cond
    [(empty? lon) 0]
    [(cons? lon) (+ (first lon)
                    (sum (rest lon)))]))

(check-expect (sum empty) 0)
(check-expect (sum (cons 10 (cons 20 empty))) 30)

(check-expect (sums empty) empty)
(check-expect (sums (cons empty empty)) (cons 0 empty))
(check-expect (sums (cons (cons 60 (cons 80 empty))
                          (cons (cons 70 (cons 40 empty))
                                (cons (cons 50 empty)
                                      empty))))
              (cons 140 (cons 110 (cons 50 empty))))