;; 1
(define insertr
  (lambda (sym follow-sym ls)
    (cond
      [(null? ls) '()]
      [(eq? (car ls) sym) (cons sym (cons follow-sym (insertr sym follow-sym (cdr ls))))]
      [else (cons sym (insertr sym follow-sym (cdr ls)))])))

;; 2
(define last
  (lambda (ls)
    (cond
      [(null? (cdr ls)) (car ls)]
      [else (last (cdr ls))])))

;; 3
(define increment
  (lambda (ls)
    (cond
      [(null? ls) '()]
      [else (cons (add1 (car ls)) (increment (cdr ls)))])))

;; 4
(define remove
  (lambda (rm-sym ls)
    (cond
      [(null? ls) '()]
      [(eq? rm-sym (car ls)) (remove rm-sym (cdr ls))]
      [else (cons (car ls) (remove rm-sym (cdr ls)))])))

;; 5
(define count-between
  (lambda (m n)
    (cond
      [(>= m n) '()]
      [else (cons m (count-between (add1 m) n))])))

;; 6
(define zip
  (lambda (ls1 ls2)
    (cond
      [(null? ls1) '()]
      [else (cons (cons (car ls1) (cons (car ls2) '()))
              (zip (cdr ls1) (cdr ls2)))])))

;; 7
(define occurs
  (lambda (sym ls)
    (cond
      [(null? ls) 0]
      [(eq? sym (car ls)) (add1 (occurs sym (cdr ls)))]
      [else (occurs sym (cdr ls))])))

;; 8
(define filter
  (lambda (pred? ls)
    (cond
      [(null? ls) '()]
      [(pred? (car ls)) (cons (car ls) (filter pred? (cdr ls)))]
      [else (filter pred? (cdr ls))])))

;; 9
(define sum-to
  (lambda (n)
    (cond
      [(= n 1) 1]
      [else (+ n (sum-to (- n 1)))])))

;; 10
(define mapit
  (lambda (p ls)
    (cond
      [(null? ls) '()]
      [else (cons (p (car ls)) (mapit p (cdr ls)))])))

;; 11
(define triple
  (lambda (ls)
    (cond
      [(null? ls) '()]
      [else (cons (car ls) (cons (car ls) (cons (car ls) (triple (cdr ls)))))])))

;; 12
(define append
  (lambda (ls1 ls2)
    (cond
      [(null? ls1) ls2]
      [else (cons (car ls1) (append (cdr ls1) ls2))])))

;; 13
(define fact
  (lambda (n)
    (if (zero? n) 1
        (* n (fact (sub1 n))))))

;; 14
(define fib
  (lambda (n)
    (cond
      [(zero? n) 0]
      [(= n 1) 1]
      [else (+ (fib (sub1 n)) (fib (- n 2)))])))

;; 15
(define even?
  (lambda (n)
    (cond
      [(= n 0) #t]
      [(= n 1) #f]
      [else (even? (+ n (if (positive? n) -2 2)))])))

;Hopefully this is what it meant by mutually recursive
(define odd?
  (lambda (n)
    (not (even? n))))

;; Brainteaser
(define fib-acc
  (lambda (n)
    (let fib-loop ([prev 0]
                   [acc 1]
                   [count 1])
      (cond
        [(= count n) acc]
        [else (fib-loop acc (+ prev acc) (add1 count))]))))