Key to CSE341 Section #7 Problems

1. One possible solution appears below:
        (define (make-sum exp1 exp2)
          (cond ((eq? exp1 0) exp2)
                ((eq? exp2 0) exp1)
                ((and (number? exp1) (number? exp2)) (+ exp1 exp2))
                (else (list '+ exp1 exp2))))
                
        (define (make-product exp1 exp2)
          (cond ((or (eq? exp1 0) (eq? exp2 0)) 0)
                ((eq? exp1 1) exp2)
                ((eq? exp2 1) exp1)
                ((and (number? exp1) (number? exp2)) (* exp1 exp2))
                (else (list '* exp1 exp2))))
        
2. One possible solution appears below:
        (define (arg2 exp) 
          (if (pair? (cdddr exp))
              (cons (car exp) (cddr exp))
              (caddr exp)))

3. The derivative function would have a new clause added for exponents:
        (define (derivative exp var)
          (cond ((number? exp) 0)
        	((symbol? exp)
        	 (if (eq? exp var) 1 0))
        	((sum? exp)
        	 (make-sum (derivative (arg1 exp) var)
        		   (derivative (arg2 exp) var)))
        	((product? exp)
        	 (make-sum
        	  (make-product (arg1 exp)
        			(derivative (arg2 exp) var))
        	  (make-product (derivative (arg1 exp) var)
        			(arg2 exp))))
        	((pow? exp)
        	 (if (eq? (arg1 exp) var)
        	     (make-product (arg2 exp)
        			   (make-pow (arg1 exp) (- (arg2 exp) 1)))
        	     0))
        	(else (error "illegal expression"))))
        
   And we'd add helper functions for testing for products and making products:
        (define (pow? exp)
          (and (pair? exp) (eq? (car exp) '^) (symbol? (cadr exp))
               (number? (caddr exp))))

        (define (make-pow exp1 exp2)
          (cond ((= exp2 0) 1)
        	((= exp2 1) exp1)
                (else (list '^ exp1 exp2))))
        
4. One possible solution appears below.
        (define (count target lst)
          (cond ((null? lst) 0)
                ((equal? (car lst) target) (+ 1 (count target (cdr lst))))
                (else (count target (cdr lst)))))
        
5. One possible solution appears below.
        (define (zip lst1 lst2)
          (if (or (null? lst1) (null? lst2))
              ()
              (cons (list (car lst1) (car lst2)) (zip (cdr lst1) (cdr lst2)))))
        
6. One possible solution appears below.
        (define (fib n)
          (define (loop n prev prevPrev)
            (let ((sum (+ prev prevPrev)))
              (if (<= n 1)
                  prev
                  (loop (- n 1) sum prev))))
          (loop n 1 1))

7. One possible solution appears below:
        (define (parse-multisequence lst)
          (let ((result (parse-sequence lst)))
            (cond ((and (> (length result) 1) (eq? '& (cadr result)))
                   (let ((result2 (parse-multisequence (cddr result))))
                     (cons (string-append (car result) "--" (car result2))
                           (cdr result2))))
                  (else result))))