Запрограммируйте функцию-предикат, проверяющую, что три из четырёх цифр в числе совпадают

> (delete-duplicates '(1 1 1 2))
(1 2)
 
> (delete-duplicates '(1 1 2 2))
(1 2)

(defun sn (n)
            (let ((table (make-hash-table)))
              (labels ((fun (num table)
                         (multiple-value-bind (f s)
                             (truncate num 10)
                           (if (> f 0)
                               (fun f (and (incf (gethash s table 0)) table))
                               (progn
                                 (incf (gethash s table 0))
                                 (loop 
                                    for v being the hash-values in table
                                    thereis (= v 3)))))))
                (fun n table))))

(defun eeq (n m
            &aux
            (s (write-to-string m))
            (u (remove-duplicates s)))
  (loop for c across u
        when (eq (count (string c) s :test #'string-equal) n)
        collect (digit-char-p c)))
 
> (eeq 3 1112)
(1)
> (eeq 3 111222)
(1 2)

(defun int-digits (n) 
  (loop for c across (write-to-string n)
        collect (digit-char-p c)))
 
(defun eeq (n m
            &aux
            (s (int-digits m))
            (u (remove-duplicates s)))
  (loop for c in u
        when (eq (count c s) n)
        collect c))
 
> (eeq 3 1112)
(1)
> (eeq 3 111222)
(1 2)

(defun eeq (n m
            &aux
            (s (loop for c across (write-to-string m)
                     collect (digit-char-p c)))
            (u (remove-duplicates s)))
  (loop for c in u
        when (eq (count c s) n)
        collect c))
 
> (eeq 3 1112)
(1)
> (eeq 3 111222)
(1 2)

(defun check (num)
  (cond ((numberp num) (check (explode num)))
        ((null num) nil)
        ((= 3 (count (car num) num))
         (cons (car num) (check (remove (car num) num))))
        ((check (remove (car num) num)))))

(defun int-digits (n &optional ac)
  (if (zerop n)
      ac
      (int-digits (truncate n 10)
                  (cons (rem n 10) ac))))
 
(defun e (w n
          &optional (v (remove-duplicates w))
          &aux (a (car v)))
  (cond ((null v) nil)
        ((= (count a w) n) (cons a (e w n (cdr v))))
        ((e w n (cdr v)))))
 
(defun eeq (n m)
  (e (int-digits m) n))
 
> (eeq 3 1112)
(1)
> (eeq 3 111222)
(1 2)

(defun int-digits (n) 
  (mapcar #'digit-char-p
          (coerce (write-to-string n) 'list)))
 
(defun e (w n
          &optional (v (remove-duplicates w))
          &aux (a (car v)))
  (when v (if (= (count a w) n)
              (cons a (e w n (cdr v)))
              (e w n (cdr v)))))
 
(defun eeq (n m)
  (e (int-digits m) n))
 
> (eeq 3 1112)
(1)
> (eeq 3 111222)
(1 2)