;; -------------------------------------------------------------------------
;; starter code for Session 11
;; -------------------------------------------------------------------------

#lang racket
(require rackunit)

;; -------------------------------------------------------------------------
;; map-nlst                                               (mutual recursion)
;; -------------------------------------------------------------------------

(define (map-nlist f nlst)
  '())

(check-equal? (map-nlist add1 '(1 4 9 16 25 36 49 64))
              '(2 5 10 17 26 37 50 65))

(check-equal? (map-nlist even? '(1 (4 (9 (16 25)) 36 49) 64))
              '(#f (#t (#f (#t #f)) #t #f) #t))

(check-equal? (map-nlist sqr '(1 (4 (9 (16 25)) 36 49) 64))
              '(1 (16 (81 (256 625)) 1296 2401) 4096))

;; -------------------------------------------------------------------------
;; simple example                                       (program derivation)
;; -------------------------------------------------------------------------

(define (2n-plus-1 n)
  (add1 (* 2 n)))

;;  (2n-plus-1 15)

;; -------------------------------------------------------------------------
;; EXAMPLE FROM READING: count-occurrences                (mutual recursion)
;; -------------------------------------------------------------------------

(define count-occurrences
  (lambda (s slist)
    (if (null? slist)
        0                                                ;; slst is empty
        (+ (count-occurrences-sym-expr s (first slist))  ;; slst is a cons
           (count-occurrences s (rest slist))) )))       ;; -solve and add

(define (count-occurrences-sym-expr s sym-expr)
  (if (symbol? sym-expr)
      (if (eq? s sym-expr) 1 0)            ;; sym-expr is a symbol
      (count-occurrences s sym-expr) ))    ;; sym-expr is an slist

(check-equal? (count-occurrences 'a '(a b c))
              1)

(check-equal? (count-occurrences 'a
                 '(((a be) a ((si be a) be (a be))) (be g (a si be))))
              5)

;; -------------------------------------------------------------------------
;; factorial, old school                                         (recursion)
;; -------------------------------------------------------------------------

(define (factorial n)
  (if (zero? n)
      1
      (* n (factorial (sub1 n)))))

;; -------------------------------------------------------------------------
;; factorial, accumulator passing style                     (tail recursion)
;; -------------------------------------------------------------------------

(define (factorial-aps n answer)
  (if (zero? n)
      answer
      (factorial-aps (sub1 n) (* n answer))))

;; -------------------------------------------------------------------------
;; factorial                                           (interface procedure)
;; -------------------------------------------------------------------------

;; (define (factorial n)
;;   (factorial-aps n 1))

;; -------------------------------------------------------------------------
;; tests for factorial                                      (either version)
;; -------------------------------------------------------------------------

(check-equal? (factorial 10)
              3628800)
(check-equal? (factorial 40)
              815915283247897734345611269596115894272000000000)

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