Написать функцию

(defun sieve (maximum)
  (let ((sieve (make-array (1+ maximum) :element-type 'bit
                                          :initial-element 0)))
    (loop for candidate from 2 to maximum
          when (zerop (bit sieve candidate))
            collect candidate
            and do (loop for composite from (expt candidate 2) 
                                         to maximum by candidate
                          do (setf (bit sieve composite) 1)))))
 
(defun div-list (n seq)
 (let ((c nil))
   (dolist (i seq (reverse c))
     (if (= (rem n i) 0) (setq c (cons i c))))))
 
(defun amount-div (n lst)
  (prog (a l i)
  a (setq a (car lst))
    (setq lst (cdr lst))
    (setq i
  (let ((i 1) (div a))
    (loop (setq n (/ n div))
          (if (/= 0 (rem n div)) (return i))
          (setq i (1+ i)))))
     (push i l)
     (cond ((null lst) (return (reverse l))))
     (go a)))
 
(defun double (s l)
  (cond
    ((null s) nil)
    ((null l) nil)
    (t (cons (list (car s) (car l)) (double (cdr s) (cdr l))))))
 
(defun Prime-factors-mult (n)
  (let* ((a (div-list n (sieve n)))
         (b (amount-div n a)))
     (double a b)))
 
> (Prime-factors-mult 315)
 
==> ((3 2) (5 1) (7 1))
 
> (Prime-factors-mult 316)
 
==> ((2 2) (79 1))

;; Построение списка простых, не превышающих n
 
(defun prime-list (n)
  (let ((plist '(2 3 5)))
        (iter (for i from 6 to n)
              (when 
                 (and (oddp i)
                      (not (iter (for j from 2 to (flo2fix (sqr i)))
                           (when (zerop (% i j)) (return t))))) (collecting i into plist)))
   plist))
 
==> prime-list
 
(prime-list 168)
 
==> (2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167)
 
;; Решение
 
(defun task (n)
  (let ((plist (prime-list n)) (res nil) (c 0) (k 0))
       (dolist (i plist res)
         (setq c 0)
         (setq k n) 
         (loop
             (cond ((zerop k) (return nil))
                   ((zerop (% k i)) (setq c (1+ c) k (\ k i)))
                   (t (return nil))))  
         (when (> c 0) (push (list i c) res)))))
            
==> task
 
(task 234)
 
==> ((13 1) (3 2) (2 1))

(task 2000)
 
==> ((5 3) (2 4))

(task 1999)
 
==> ((1999 1))