Заданы три списка. Удалить из первого списка все элементы остальных списков

;;; найти элемент в списке
(defun my-find (elm lst)
  (if (null lst)
      nil
      ;; если найдет вернуть, иначе искать в подсписке
      (if (eql elm (car lst))
      elm
      (my-find elm (cdr lst)))))
 
;;; рекурсивная реализация set-difference (разница между множествами)
(defun my-set-diff-rec (lst rem res)
  ;; находит res = lst \ rem (где \ - операция разности)
 
  (if (null lst)
      res
      (let ((head (car lst)))   ; для всех элементов lst
    (if (my-find head rem)  ; если не найден в rem, добавить к res
        (my-set-diff-rec (cdr lst) rem res)
        (my-set-diff-rec (cdr lst) rem (cons head res))))))
 
;;; удаление элементов из списка lst, присутствующих в rem
(defun my-set-diff (lst rem)
  (my-set-diff-rec lst rem nil))
 
;;; test
(defparameter *baby-names* '(vasya petya natasha vera sasha))
(defparameter *father-doesnt-like* '(sasha natasha))
(defparameter *mother-doesnt-like* '(vera vasya))
 
(defparameter *names-both-like*
  (my-set-diff (my-set-diff *baby-names* *father-doesnt-like*)
           *mother-doesnt-like*))
 
(princ *names-both-like*)

(defun clear-twins (w x z &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((or (member a x) (member a z)) (clear-twins d x z))
        ((cons a (clear-twins d x z)))))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun task (a b c)
  (diflist (diflist a b) c))
 
==> task
 
(task '(a b c) '(b) '(c))
 
==> (a)

(defun clear-twins (w x z)
  (set-difference w (union x z)))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun task (x y z)
  (diflist x (union y z)))
 
==> task
 
(task '(1 2 3 4 5) '(2 4) '(5 6 7))
 
==> (1 3)

(defun -union (w v)
  (cond ((null w) v)
        ((member (car w) v) (-union (cdr w) v))
        ((cons (car w) (-union (cdr w) v)))))
 
> (union '(1 2 3 4) '(4 5 6 7 8 9))
(1 2 3 4 5 6 7 8 9)
> (-union '(1 2 3 4) '(4 5 6 7 8 9))
(1 2 3 4 5 6 7 8 9)

(defun -union (x y)
  (cond ((null x) y)
        ((null y) x)
        ((member (car x) y) (-union (cdr x) y))
        (t (-union (cdr x) (cons (car x) y)))))
 
> (-union '(1 2 3 4) '(4 5 6 7 8 9))
(3 2 1 4 5 6 7 8 9)

(defun clear-twins (w x z &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((or (member a x) (member a z)) (clear-twins d x z))
        ((cons a (clear-twins d x z)))))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun clear-twins (w x z &aux (a (car w)))
  (when w (if (or (member a x) (member a z))
              (clear-twins (cdr w) x z)
              (cons a (clear-twins (cdr w) x z)))))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun clear-twins (w x z)
  (set-difference (set-difference w x) z))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun clear-twins (w &rest v) (clear w v))
 
(defun clear (w v)
  (if v (clear (set-difference w (car v))
               (cdr v))
      w))
 
> (clear-twins '(a b c) '(b) '(c))
(A)

(defun clear-twins (w &rest v)
  (dolist (a v)
    (setf w (set-difference w a)))
  w)
 
> (clear-twins '(a b c) '(b) '(c))
(A)