(define average-list
  (lambda (alist)
    (average-list-help alist 0 0)))

(define average-list-help
  (lambda (alist total count)
    (cond ((and (null? alist) 
                (= count 0))     0)
          ((null? alist)         (/ total count))
          ((number? (car alist)) (average-list-help (cdr alist)
                                                    (+ total (car alist))
                                                    (+ count 1)))
          (else                  (average-list-help (cdr alist)
                                                    total
                                                    count)))))
(define make-list
  (lambda (n)
    (cond ((<= n 0) '())
          (else (cons '() (make-list (- n 1)))))))



(define crossproduct (lambda (vector1 vector2)

        (if (null? vector1) ()
            (cons (* (car vector1) (car vector2))
                  (crossproduct (cdr vector1) (cdr vector2))))))

(define crossproduct-tr (lambda (vector1 vector2)
          (crossproduct-hlp-tr vector1 vector2 () )))

(define crossproduct-hlp-tr (lambda (vector1 vector2 result)
          (if (null? vector1) result
              (crossproduct-hlp-tr (cdr vector1) (cdr vector2)
                  (append result (list (* (car vector1) (car vector2))))))))


(define delete-every-nth (lambda (n lst)
        (if (= n 0) lst
            (delete-hlp n lst 1))))

(define delete-hlp (lambda (n lst count)
        (COND ((null? lst) ())
              ((= count n)
               (delete-hlp n (cdr lst) 1))
              (else (cons (car lst) 
                          (delete-hlp n (cdr lst) (+ 1 count)))))))

(define delete-every-nth-tr (lambda (n lst)
        (if (= n 0) lst
            (delete-hlp-tr n lst 1 () ))))

(define delete-hlp-tr (lambda (n lst count result)
        (COND ((null? lst) result)
              ((= count n)
               (delete-hlp-tr n (cdr lst) 1 result))
              (else (delete-hlp-tr n (cdr lst) (+ 1 count) 
                                   (append result (list (car lst))))))))


(define even-list (lambda (lst)
        (even-list-hlp lst 1)))

(define even-list-hlp (lambda (lst count)
        (COND ((null? lst) ())
              ((even? count) 
               (cons (car lst)
                     (even-list-hlp (cdr lst) (+ count 1))))
              (else (even-list-hlp (cdr lst) (+ count 1))))))


(define even-list-tr (lambda (lst)
        (even-list-hlp-tr lst 1 () )))

(define even-list-hlp-tr (lambda (lst count result)
        (COND ((null? lst) result)
              ((even? count) 
               (even-list-hlp-tr (cdr lst) (+ count 1) 
                                 (my-append result (list (car lst)))))
              (else (even-list-hlp-tr (cdr lst) (+ count 1) result)))))


50
107
N DIV 2
O(N)

append causes a summation

(5*6)/2 = 15
(6*7)/2 = 21
Let P = N DIV 2
   (P^2 + P)/2
O(N^2)


(define odd-list (lambda (lst)
        (odd-list-hlp lst 1)))

(define odd-list-hlp (lambda (lst count)
        (COND ((null? lst) ())
              ((odd? count) 
               (cons (car lst)
                     (odd-list-hlp (cdr lst) (+ count 1))))
              (else (odd-list-hlp (cdr lst) (+ count 1))))))

(define odd-list-tr (lambda (lst)
        (odd-list-hlp-tr lst 1 () )))

(define odd-list-hlp-tr (lambda (lst count result)
        (COND ((null? lst) result)
              ((odd? count) 
               (odd-list-hlp-tr (cdr lst) (+ count 1) 
                                (my-append result (list (car lst)))))
              (else (odd-list-hlp-tr (cdr lst) (+ count 1) result)))))


50
108
1 + (N DIV 2)
O(N)


The append causes a summation

(5*6)/2 = 15
(7*8)/2 = 28
(P^2 + P)/2 where P= 1 + (N DIV 2) if n is odd

                              or
               
                     (N DIV 2) if n is even        
O(N^2)

(define n-list (lambda (n lst)
        (n-list-hlp n lst 1)))

(define n-list-hlp (lambda (n lst count)
        (COND ((null? lst) ())
              ((mult-of-n n count)
               (cons (car lst)
                     (n-list-hlp n (cdr lst) (+ count 1))))
              (else (n-list-hlp n (cdr lst) (+ count 1))))))
              
(define mult-of-n (lambda (n num)
        (= (modulo num n) 0)))

(define n-list-tr (lambda (n lst)
        (n-list-hlp-tr n lst 1 () )))

(define n-list-hlp-tr (lambda (n lst count result)
        (COND ((null? lst) result)
              ((mult-of-n n count)
               (n-list-hlp-tr n (cdr lst) (+ count 1) 
                           (append result (list (car lst)))))
              (else (n-list-hlp-tr n (cdr lst) (+ count 1)
                                   result)))))

20
12
M DIV P
O(M DIV P)

append causes a summation

(3*4)/2 = 6
(5*6)/2 = 15
Let Q = M DIV P
   (Q^2 + Q)/2
Let Q = M DIV P
    O(Q^2)


(define insert-left-all (lambda (insert find lst)
        (COND ((null? lst) ()) 
              ((equal? find (car lst))
               (cons insert (cons (car lst)
                                  (insert-left-all insert find (cdr lst)))))
              ((list? (car lst)) 
                      (cons (insert-left-all insert find (car lst)) 
                            (insert-left-all insert find (cdr lst))))
              (else (cons (car lst) 
                          (insert-left-all insert find (cdr lst)))))))

(define insert-right-all (lambda (insert find lst)
        (COND ((null? lst) ()) 
              ((equal? find (car lst))
               (cons (car lst) (cons insert
                               (insert-right-all insert find (cdr lst)))))
              ((list? (car lst)) 
                      (cons (insert-right-all insert find (car lst)) 
                            (insert-right-all insert find (cdr lst))))
              (else (cons (car lst) 
                          (insert-right-all insert find (cdr lst)))))))



(define butlast (lambda (lst)
     (COND ((null? lst) ())
           ((null? (cdr lst)) ())
           ((list? (car lst)) (cons (butlast (car lst))
                                    (butlast (cdr lst))))
           (else (cons (car lst) (butlast (cdr lst)))))))