(define (rfactorial n)
  (if ( = n 0)
    1
    (* n (rfactorial (- n 1)))
  )
)

(define (ifactorial n)
  (define (factorial-helper n total)
    (if (= n 0)
      total
      (factorial-helper (- n 1) (* total n))
    )
  )
  (factorial-helper n 1)
)

(define (length lst)
  (if (null? lst)
    0
    (+ 1 (length (cdr lst)))
  )
)

(define (length-tail lst)
  (define (length-helper lst total)
    (if (null? lst)
      total
      (length-helper (cdr lst) (+ 1 total))
    )
  )
  (length-helper lst 0)
)

(define (reverse lst)
  (define (reverse-helper lst result)
    (if (null? lst)
      result
      (reverse-helper (cdr lst) (cons (car lst) result))
    )
  )
  (reverse-helper lst '())
)

(define (interleave l1 l2 l3)
  (define (interleave-helper l1 l2 l3 result)
    (if (null? l1)
      result
      (interleave-helper l2 l3 (cdr l1) (cons (car l1) result))
    )
  )
  (reverse (interleave-helper l1 l2 l3 '()))
)

(define (map fn lst)
  (define (map-helper lst result)
    (if (null? lst) 
      result
      (map-helper (cdr lst) (cons (fn (car lst)) result))
    )
  )
  (reverse (map-helper lst '()))
)

(define square (lambda (x) (* x x)))

(define (square-lst lst)
  (define (square-lst-helper lst result)
    (if (null? lst)
      result
      (square-lst-helper 
        (cdr lst) 
        (cons (square (car lst))
          result))
    )
  )
  (reverse (square-lst-helper lst '()))
)

(define (square-lst2 lst)
  (map square lst)
)

(define (enumerate-partitions n m)
  (cond 
    ((= n 0) '(()))
    ((or (< n 0) (= m 0)) '())
    (else (append 
              (map (lambda (l) (cons m l)) (enumerate-partitions (- n m) m))
              (enumerate-partitions n (- m 1))
    ))
  )
)