ANSI Common Lisp Practice - My Answers - Chatper - 2

I work out the questions by myself

Chapter 2

---

question 4.

(defun greater (x y)
    (if (> x y)
        x
        y
    )
)

question 5.

(a)

(defun enigma (x)
    (and (not (null x))
        (or (null (car x))
            (enigma (cdr x))
        )
    )
)
; to judge whether there is a nil in x

(b)

(defun mystery (x y)
    (if (null y)
        nil
        (if (eql (car y) x)
            0
            (let ((z (mystery x (cdr y))))
                (and z (+ z 1))
            )
        )
    )
)
; return the index of x in y (if not exist, return nil)

question 6.

(a) (car (car (cdr '(a (b c) d))))

(b) (or 13 (/ 1 0))

(c) (funcall (lambda (x y z) (list (car (funcall x y z)))) #'list 1 nil)

question 7.

; recursive version

(defun testlist (x)
    (if (not (listp x))
        nil ; not list, return nil
        (if (null x)
            nil ; is empty, return nil
            (if (listp (car x))
                t ; match the request, return true
                (testlist (cdr x)) ; recurisvely test the rest
            )
        )
    )
)

; iterative version

(defun testlist (x)
    (if (not (listp x))
        nil ; not list, return nil
        (if (null x)
            nil
            (let ((res nil))
                (dolist (obj x)
                    (if (listp obj)
                        (setf res t) ; res to record the judgement
                        nil
                    )
                )
                res ; return res
            )
        )
    )
)

question 8.

(a)

; iterative

(defun PrintDot (x)
    (do ((i 1 (+ i 1)))
        ((> i x) 'done)
        (format t ".")
    )
    (format t "~%")
)

; recursive

(defun PrintDot (x)
    (if (> x 0)
        (progn
            (format t ".")
            (PrintDot (- x 1))
        )
        nil
    )
)

(b)

; iterative

(defun testa (x)
    (if (not (listp x))
        nil
        (let ((res 0))
            (dolist (obj x)
                (if (eql obj 'a)
                    (setf res (+ res 1))
                )
            )
            res
        )
    )
)

; recursive

(defun testa (x)
    (if (not (listp x))
        nil
        (if (null x)
            0
            (let
                ((z (if (eql (car x) 'a)
                    1
                    0
                )))
                (setf z (+ z (testa (cdr x))))
                z
            )
        )
    )
)

question 9.

(a)

(defun summit (lst)
    (setf lst (remove nil lst))
    (apply #'+ lst)
)

(b)

(defun summit (lst)
    (if (null lst)
        0
        (let ((x (car lst)))
            (if (null x)
                (summit (cdr lst))
                (+ x (summit (cdr lst)))
            )
        )
    )
)