Написать функцию, возвращающую список частот атомов, входящих в исходный список

;;; racket-lang.org
(define (count a lst (acc 0))
  (cond [(null? lst) acc]
        [(eq? a (car lst)) (count a (cdr lst) (add1 acc))]
        [(count a (cdr lst) acc)]))
 
(define (foo lst)
  (let loop ((l (remove-duplicates lst)) (acc null))
    (if (null? l)
        acc
        (loop (cdr l) (cons (list (car l) (count (car l) lst)) acc)))))
 
(foo '(a a a s s d d d d))
;'((d 4) (s 2) (a 3))

(defun task (lst)
  (let* ((flst (flatten lst))
         (lf   (length flst)) 
         (slst (setof flst)))
        (mapcar #'(lambda (x) (list x (- lf (length (remove x flst))))) slst)))
 
  
 
==> task
 
(task '(a b c ((a b c c c) d e d)))
 
==> ((a 2) (b 2) (c 4) (e 1) (d 2))

(defun flatten-and-count (w
                     &aux
                     (z (flat w))
                     (v (remove-duplicates z)))
  (mapcar #'(lambda (a) (list a (count a z))) v))
 
(defun flat (w &optional acc) 
  (cond ((null w) acc)
        ((atom w) (cons w acc))
        ((flat (car w) (flat (cdr w) acc)))))
 
> (flatten-and-count '(a (b (b) c) (c) c))
((A 1) (B 2) (C 3))

;;; racket-lang.org
(define (foo lst (l (flatten lst)))
  (for/list ((i (remove-duplicates l)))
    (list i (length (filter (lambda (x) (eq? i x)) l)))))