(define eval-poly
  (lambda (x poly)
    (cond ((null? poly)
           0)
          (else (+ (* (caar poly) (expt x (cdar poly)))
                   (eval-poly x (cdr poly)))))))

(define tail
  (lambda (n lst)
    (tail-help (- (length lst) n) lst)))

(define tail-help
  (lambda (n lst)
    (cond ((< n 0) #f)
          ((= n 0) lst)
          (else (tail-help (sub1 n) (cdr lst))))))

(define remove*
  (lambda (l)
    (cond ((null? l) '())
          ((symbol? (car l)) (remove* (cdr l)))
          (else (cons (remove* (car l)) (remove* (cdr l)))))))

(define select
  (lambda (n l)
    (map (lambda (l) (select-help n l)) l)))

(define select-help
  (lambda (n l)
    (cond ((null? l) #f)
          ((= n 1) (car l))
          (else (select-help (sub1 n) (cdr l))))))

(define map
  (lambda (f l)
    (if (null? l)
        '()
        (cons (f (car l)) (map f (cdr l))))))

(define replace
  (lambda (v n lst)
    (cond ((null? lst) '())
          ((zero? n) (cons v (cdr lst)))
          (else (cons (car lst) (replace v (- n 1) (cdr lst)))))))

(define depth
  (lambda (l)
    (cond ((null? l) 0)
          ((symbol? (car l)) (depth (cdr l)))
          (else (max (+ 1 (depth (car l))) (depth (cdr l)))))))

(define max
  (lambda (a b)
    (if (< a b)
        b
        a)))

(define follow
  (lambda (s l)
    (follow-help s (flatten l))))

(define follow-help
  (lambda (s l)
    (cond ((null? l) #f)
          ((null? (cdr l)) #f)
          ((eq? (car l) s) (cadr l))
          (else (follow-help s (cdr l))))))

(define flatten
  (lambda (l)
    (cond ((null? l) '())
          ((symbol? (car l)) (cons (car l) (flatten (cdr l))))
          (else (append (flatten (car l)) (flatten (cdr l)))))))

(define expand
  (lambda (n)
    (expand-help n 1)))

(define expand-help
  (lambda (n p)
    (cond ((= 0 n) '())
          ((= 1 n) (list p))
          (else (list p (expand-help (sub1 n) (add1 p)))))))

(define union
  (lambda (lset)
    (foldr union2 '() lset)))

(define union2
  (lambda (a b)
    (cond ((null? a) b)
          ((member (car a) b) (union2 (cdr a) b))
          (else (cons (car a) (union2 (cdr a) b))))))

(define foldr
  (lambda (f i l)
    (if (null? l)
        i
        (f (car l) (foldr f i (cdr l))))))

(define permute
  (lambda (los)
    (cond ((null? los) '())
          ((null? (cdr los)) (list los))
          (else
            (let ((perms (permute (cdr los))))
              (foldr append
                '()
                (map (lambda (p)
                       (natural-map
                         (lambda (n)
                           (insert (car los) n p))
                         (length p)))
                     perms)))))))

(define natural-map
  (lambda (f n)
    (if (< n 0)
        '()
        (cons (f n) (natural-map f (sub1 n))))))

(define insert
  (lambda (v n l)
    (if (zero? n)
        (cons v l)
        (cons (car l) (insert v (sub1 n) (cdr l))))))