Answers to Rec 11

NOTE: There are many possible alternative answers.
------------------------------------------
11.1  No answer asked for.
------------------------------------------
11.2
> (defun maxvec (x)
   (cond
      ((null (cdr x)) (car x))
      ((> (car x) (maxvec (cdr x))) (car x))
      (t (maxvec (cdr x)))) ))
MAXVEC
> (maxvec '(2 5 6 3))
6
> (maxvec '(6 2 3))
6
> (maxvec '(6 2 3 7))
7
> (maxvec '(6))
6
> (defun maxvec (x)
   (cond
      ((null (cdr x)) (car x))
      (t (max (car x) (maxvec (cdr x)))) ))
MAXVEC
> (maxvec '(2 5 6 3))
6
> (maxvec '(6 2 3 7))
7
------------------------------------------
11.3
> (defun count-atoms (x)
   (cond
      ((null x) 0)
      ((atom x) 1)
      (t (+ (count-atoms (car x)) (count-atoms (cdr x)))) ))
COUNT-ATOMS
> (count-atoms '(a (b c) (d (e) f)))
6
> (count-atoms '(((a b) c) d (a (b) ((c)))))
7
> (count-atoms '((((a)))))
1
------------------------------------------
11.4
> (defun vecmul (x y)
   (cond
      ((null (cdr x)) (list (* (car x) (car y))))
      (t (append (list (* (car x) (car y))) (vecmul (cdr x) (cdr y))))) ))
VECMUL
> (vecmul '(2 3 4 5) '(1 4 5 2))
(2 12 20 10)
> (defun vecmul (a b)
   (cond
      ((null a) nil)
      (t (append (list (* (car a) (car b))) (vecmul (cdr a) (cdr b)))) ))
VECMUL
> (vecmul '(2 3 4 5) '(1 4 5 2))
(2 12 20 10)
------------------------------------------
11.5
> (defun addvec (list)
      (cond ((null list) 0)
      (t (+ (car list) (addvec (cdr list)))) ))
ADDVEC
> (defun innprod (a b) (addvec (vecmul a b)))
INNPROD
> (setq a '(1 2 3))
(1 2 3)
> (setq b '(4 5 6))
(4 5 6)
> (innprod a b)
32
------------------------------------------
11.6
> (defun insert1 (x y)
   (cond
      ((null y) (list x))
      ((< x (car y)) (append (list x) y))
      (t (append (list (car y)) (insert1 x (cdr y)))) ))
INSERT1
> (insert1 3 '(1 4 6 6 7))
(1 3 4 6 6 7)
> (insert1 3 '(4 5 6))
(3 4 5 6)
> (insert1 7 '(2 3 4))
(2 3 4 7)
> (insert1 3 '())
(3)

NOTE: '() above could have been just ()
------------------------------------------
11.7
> (defun sort1 (x)
   (cond
      ((null x) nil)
      (t (insert1 (car x) (sort1 (cdr x)))) ))
SORT1
> (sort1 '(9 8 7 6 5))
(5 6 7 8 9)
> (sort1 '(5 6 7 8 9))
(5 6 7 8 9)
> (sort1 '(5))
(5)
> (sort1 '(2 8 4 3 7))
(2 3 4 7 8)
------------------------------------------
11.8
> (defun reverse1 (x)
   (cond ((null x) nil)
         (t (append (reverse1 (cdr x)) (list (car x))))))
REVERSE1
> (reverse1 '(a b c))
(C B A)
> (reverse1 '(a))
(A)
> (reverse1 '((a b) c ((d e) f)))
(((D E) F) C (A B))
------------------------------------------
11.9
> (defun srev (x)
   (cond ((null x) nil)
         ((atom (car x)) (append (srev (cdr x)) (list (car x))))
         (t (append (srev (cdr x)) (list (srev (car x))))) ))

> (srev '(a b))
(B A)
> (srev '((a b (c d)) e (f g)))
((G F) E ((D C) B A))
> (srev '(a))
(A)

NOTE: when I first wrote this, I left off the "list" on the last line
(after making many earlier errors).  Result without that "list"
> (srev '((a b (c d)) e (f g)))
(G F E D C B A)
------------------------------------------
11.10 Just plugging in
------------------------------------------
11.11
> (defun addvec (x) (apply '+ x))
ADDVEC
> (defun vecmul (x y) (mapcar '* x y))
VECMUL
> (defun innprod (x y) (addvec (vecmul x y)))
INNPROD
> (defun innprod2 (x y) (apply '+ (mapcar '* x y)))
INNPROD2
> (setq a '(1 2 3))
(1 2 3)
> (setq b '(4 5 6))
(4 5 6)
> (setq c '(7 8 9))
(7 8 9)
> (setq d '(11 13 17))
(11 13 17)
> (vecmul a b)
(4 10 18)
> (innprod a b)
32
> (innprod2 a b)
32
> (vecmul c d)
(77 104 153)
> (innprod  c d)
334
> (innprod2 c d)
334
------------------------------------------
11.12
                  +---+---+    +---+---+          +---+---+
((a b) c (d)):--->| o | o-|--->| o | o-|--------->| o | o-|---> nil
                  +---+---+    +---+---+          +---+---+
                    |            |                  |
                    |            v                  v
                    |            c                +---+---+
                    |                             | o | o-|---> nil
                    v                             +---+---+
                  +---+---+    +---+---+            |
                  | o | o-|--->| o | o-|---> nil    v
                  +---+---+    +---+---+            d
                    |            |
                    v            v
                    a            b

> '( (a . (b . nil) ) . (c . ( (d . nil) . nil) ) )
((A B) C (D))
Note: Answer was trivial because Lisp always displays with fewest number of dots.
------------------------------------------