Определить функцию пересечение х у

(defun merge*(l1 l2)
    (dolist (i l1)
        (if (not (member i l2))
            (setf l2 (cons i l2))))
    l2)
 
(defun open-list(l &optional (acc nil))
    (if (null l)
        acc
        (let ((h (car l)))
            (if (atom h)
                (open-list (cdr l) (if (member h acc) acc (cons h acc)))
                (open-list (cdr l) (merge* (open-list h) acc))))))
 
(defun cross(a b)
    (let ((oa (open-list a))
          (ob (open-list b))
          (acc nil))
        (dolist (i oa)
            (if (member i ob)
                (setf acc (cons i acc))))
        acc))

> (cross '((1) 3 4 (3)) '((3 4) 5))
 
(3 4)

(defun flat (w &optional acc) 
  (cond ((null w) acc)
        ((atom w) (cons w acc))
        ((flat (car w) (flat (cdr w) acc)))))
 
(defun inter (w v)
  (cond ((null w) nil)
        ((or (not (member (car w) v)) (member (car w) (cdr w)))
         (inter (cdr w) v))
        ((cons (car w) (inter (cdr w) v)))))
 
(defun insection (w v)
  (inter (flat w) (flat v)))
 
> (insection '((1) 3 4 (3)) '((3 4) 5))
(4 3)

(defun flat (w &optional acc) 
  (cond ((null w) acc)
        ((atom w) (cons w acc))
        ((flat (car w) (flat (cdr w) acc)))))
 
(defun inter (w v &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((or (not (member a v)) (member a d)) (inter d v))
        ((cons a (inter d v)))))
 
(defun insection (w v)
  (inter (flat w) (flat v)))
 
> (insection '((1) 3 4 (3)) '((3 4) 5))
(4 3)

(defun unique (w &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((member a d) (unique d))
        ((cons a (unique d)))))
 
(defun flat (w &optional acc) 
  (cond ((null w) acc)
        ((atom w) (cons w acc))
        ((flat (car w) (flat (cdr w) acc)))))
 
(defun inter (w v &aux (a (car w)) (d (cdr w)))
  (cond ((null w) nil)
        ((member a v) (cons a (inter d v)))
        ((inter d v))))
 
(defun insection (w v)
  (inter (unique (flat w)) (unique (flat v))))
 
> (insection '((1) 3 4 (3)) '((3 4) 5))
(4 3)

;; аналог обычного append, но не присоединяющий атомы, уже входящие в первый список
 
(defun uappend (x y)
  (cond ((null y) x)
        ((null x) y)
        ((member (car x) y) (uappend (cdr x) y))
        (t (cons (car x) (uappend (cdr x) y))))) 
  
;; построение списка уникальных атомов произвольного списка:
 
(defun alist (x &optional res)
  (cond ((null x) res)
        ((And (atom (car x)) (Not (member (car x) res))) (alist (cdr x) (cons (car x) res)))
        ((listp (car x)) (alist (cdr x) (uappend (alist (car x) res) res)))
        (t (alist (cdr x) res)))) 
 
==> alist
 
(alist '(1 (2 1 3) 1))
 
==> (3 2 1)
 
(alist '(1 (2 1 3) 1 1 (((1 2 3 4 5)))))
 
==> (5 4 3 2 1)
 
;; Пересечение двух списков, содержащих только уникальные атомы:
 
(defun intersect (L1 L2 &optional r)
   (cond ((null L1) r)
         ((member (car L1) L2) (intersect (cdr L1) L2 (cons (car L1) r)))
         (t (intersect (cdr L1) L2 r))))
 
 
==> intersect
 
(intersect '(1 2 3 4 5) '(5 6 1 3 7 8 9 10 2))
 
==> (5 3 2 1)
 
;; Решение задачи:
 
(defun solve-task (x y)
  (intersect (alist x) (alist y)))
 
==> solve-task
 
(solve-task '(1 2 (((3 4 5))) 6 7) '(3 4 (((5)))))
 
==> (3 4 5)