

Definition

A factorion is a natural number that equals the sum of the factorials of its digits.



Example
 
145   is a factorion in base 10 because:


          1! + 4! + 5!   =   1 + 24 + 120   =   145 





It can be shown (see talk page) that no factorion in base 10 can exceed   1,499,999.



Task

Write a program in your language to demonstrate, by calculating and printing out the factorions, that:

   There are   3   factorions in base   9
   There are   4   factorions in base 10
   There are   5   factorions in base 11 
   There are   2   factorions in base 12     (up to the same upper bound as for base 10)


See also

 Wikipedia article
 OEIS:A014080 - Factorions in base 10
 OEIS:A193163 - Factorions in base n


(defparameter *bases* '(9 10 11 12))
(defparameter *limit* 1500000)
 
(defun ! (n) (apply #'* (loop for i from 2 to n collect i)))
 
(defparameter *digit-factorials* (mapcar #'! (loop for i from 0 to (1- (apply #'max *bases*)) collect i)))
 
(defun fact (n) (nth n *digit-factorials*))
 
(defun digit-value (digit)
  (let ((decimal (digit-char-p digit)))
    (cond ((not (null decimal)) decimal)
          ((char>= #\Z digit #\A) (+ (char-code digit) (- (char-code #\A)) 10))
          ((char>= #\z digit #\a) (+ (char-code digit) (- (char-code #\a)) 10))
          (t nil))))
 
(defun factorionp (n &optional (base 10))
  (= n (apply #'+
            (mapcar #'fact
                    (map 'list #'digit-value
                         (write-to-string n :base base))))))
 
(loop for base in *bases* do
  (let ((factorions
        (loop for i from 1 while (< i *limit*) if (factorionp i base) collect i)))
    (format t "In base ~a there are ~a factorions:~%" base (list-length factorions))
    (loop for n in factorions do
      (format t "~c~a" #\Tab (write-to-string n :base base))
      (if (/= base 10) (format t " (decimal ~a)" n))
      (format t "~%"))
    (format t "~%")))