Написать программу, возвращающую список вида: первый элемент — атом исходного списка, появляющийся в списке один раз (с

(defun flatten (lst) ;; Сделать список одноуровневым 
   (cond ((null lst) nil) 
            ((atom (car lst)) (cons (car lst) (flatten (cdr lst)))) 
            (t (append (flatten (car lst)) (flatten (cdr lst)))))) 
 
(defun mkpair (lst);; Строим список пар (атом число_вхождений) 
          (cond ((null lst) nil) 
                   (t (let* ((a (car lst)) 
                               (c (remove a lst)) 
                               (n (- (length lst) (length c)))) 
                      (cons (list a n) (mkpair c)))))) 
 
(defun qsort (plist) ;; Сортировка по числу вхождений 
          (cond ((null plist) nil) 
                   (t (append (qsort (remove-if (lambda (z) (> (cadr z) (cadar plist))) (cdr plist))) 
                                   (list (car plist)) 
                                   (qsort (remove-if (lambda (z) (<= (cadr z) (cadar plist))) (cdr plist))))))) 
 
(defun group (plist &optional (n 0) (r nil));; Группировка 
          (cond ((null plist) (if (null (cdr r)) r (list r))) 
                   ((zerop n) (group (cdr plist) (cadar plist) (list (caar plist)))) 
                   ((= (cadar plist) n) (group (cdr plist) n (cons (caar plist) r))) 
                   (t (if (null (cdr r)) 
                      (cons (car r) (group (cdr plist) (cadar plist) (list (caar plist)))) 
                      (cons r (group (cdr plist) (cadar plist) (list (caar plist)))))))) 
 
(defun task (lst);; Решение задачи 
          (group (qsort (mkpair (flatten lst))))) 
 
(write(task '(a b c (a ((b c) c) c) c)))
((A B) C)

(defun add-empty (lst &optional (n 1) (m (apply 'max lst)))
  (if (> n m) nil
      (if (member n lst) (add-empty lst (+ n 1) m)
                         (cons (list (list '_) n) (add-empty lst (+ n 1) m)))))

(defun task (lst)
  (let* ((pairs (mkpair (flatten lst)))
         (nlst  (mapcar 'cadr pairs))
         (empl  (add-empty nlst))
         (alst  (group (qsort (append pairs empl)))))
        (mapcar (lambda (x) (if (equal x '(_)) nil x)) alst)))
 
 
(task '(a b c (a ((b c) c) c) c))
==> (NIL (A B) NIL NIL C)