;;; ====================================================
;;;  CMPU-101, Fall 2009
;;;  Code from class
;;;  Sept. 22, 2009
;;; ====================================================

(load "asmt-helper.txt")

(header "Code from class" "Sept. 22, 2009")

(problem "compute-tax")

;;;  COMPUTE-TAX
;;; ----------------------------------------
;;;  INPUT:  INCOME, number
;;;  OUTPUT:  TAX, number
;;;   where income below $10000 taxed at 10%
;;;         income between $10000 and $30000 taxed at 15%
;;;     and income above $30000 taxed at 25%
;;; ----------------------------------------
;;;  NOTE:  Even if you earn more than $10000, the first
;;;         $10000 you earn is taxed at 10%.  Only the
;;;         amount *above* $10000 is taxed at higher rates.

(define compute-tax
  (lambda (income)
    (cond

      ;; Case 1:  All income taxed at 10% rate
      ((<= income 10000)
       (* .10 income))
      
      ;; Case 2:  First $10000 taxed at 10% rate,
      ;;          the rest taxed at 15% rate
      ((<= income 30000)
       (+ (* .10 10000) ; (i.e., $1000 in tax)
          (* .15 (- income 10000))))
      
      ;; Case 3:  First $10000 taxed at 10% rate,
      ;;          income between $10000 and $30000 taxed at 15%
      ;;          and income above $30000 taxed at 25%
      (#t
       (+ (* .10 10000) ; (i.e., $1000 in tax)
          (* .15 (- 30000 10000)) ; (i.e., $3000 in tax)
          (* .25 (- income 30000)))))))

(tester '(compute-tax 0)) ; 0
(tester '(compute-tax 1)) ; .10
(tester '(compute-tax 6000)) ; 600
(tester '(compute-tax 10000)) ; 1000
(tester '(compute-tax 10001)) ; 1000.15
(tester '(compute-tax 14000)) 
(tester '(compute-tax 30000)) ; 1000 + 3000 = 4000
(tester '(compute-tax 30001)) ; 4000.25
(tester '(compute-tax 100000))
(tester '(compute-tax 65000))


(problem "factorial")

;;;  FACTORIAL
;;; -------------------------------------
;;;  INPUT:  NUM, integer (>= 0)
;;;  OUTPUT:  Factorial of NUM

;;;  ==> This version uses COND (easier to insert comments)

(define factorial
  (lambda (num)
    (cond
      ;; Base Case: Num = 0
      ((= num 0)
       1)
      ;; Recursive Case:  Num > 0
      (#t
       (* num (factorial (- num 1))))
    )))

(tester '(factorial 0)) ; 1
(tester '(factorial 1)) ; 1
(tester '(factorial 2)) ; 2
(tester '(factorial 3)) ; 6
(tester '(factorial 4)) ; 24
(tester '(factorial 10))
(tester '(factorial 20))

;;;  ==> This version uses IF (comments a little trickier)

(define factorial-v2
  (lambda (num)
    (if (<= num 0) ; Base Case: num = 0
        1          ; 0! = 1
        ;; Recursive Case:  num > 0
        (* num (factorial-v2 (- num 1)) ; num! = num * (num - 1)!
    ))))

(newline)
(tester '(factorial-v2 0)) ; 1
(tester '(factorial-v2 1)) ; 1
(tester '(factorial-v2 2)) ; 2
(tester '(factorial-v2 3)) ; 6
(tester '(factorial-v2 4)) ; 24
(tester '(factorial-v2 10))
(tester '(factorial-v2 20))


(problem "sum-squares")

;;;  SUM-SQUARES
;;; --------------------------------------
;;;  INPUT:  NUM, integer (>= 1)
;;;  OUTPUT:  Sum of the squares from 1 to NUM
;;;           (i.e., 1*1 + 2*2 + ... NUM*NUM)

(define sum-squares
  (lambda (num)
    (cond
      ;; Base Case:  Num = 1
      ((= num 1)
       1)
      ;; Recursive Case:  
      (#t
       ;; Let recursive function call do most of the work!
       (+ (sum-squares (- num 1))
          (* num num))))))

(tester '(sum-squares 1))
(tester '(sum-squares 2))
(tester '(sum-squares 3))
(tester '(sum-squares 4))
(tester '(sum-squares 50))
(tester '(sum-squares 100))