Factorions

Factorions is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Definition

A factorion is a natural number that equals the sum of the factorials of its digits. For example 145 is a factorion in base 10 because:

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

Task

It can be shown (see Wikipedia article below) that no factorion in base 10 can exceed 1,499,999.

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

1. There are 4 factorions in base 10.

2. There are 3 factorions in base 9, 5 factorions in base 11 but only 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

ALGOL 68

Template:Frans <lang algol68>BEGIN

   # cache factorials from 0 to 11 #
   [ 0 : 11 ]INT fact;
   fact[0] := 1;
   FOR n TO 11 DO
       fact[n] := fact[n-1] * n
   OD;
   FOR b FROM 9 TO 12 DO
       print( ( "The factorions for base ", whole( b, 0 ), " are:", newline ) );
       FOR i TO 1500000 - 1 DO
           INT sum := 0;
           INT j := i;
           WHILE j > 0 DO
               sum +:= fact[ j MOD b ];
               j OVERAB b
           OD;
           IF sum = i THEN print( ( whole( i, 0 ), " " ) ) FI
       OD;
       print( ( newline ) )
   OD

END</lang>

Output:

The factorions for base 9 are:
1 2 41282
The factorions for base 10 are:
1 2 145 40585
The factorions for base 11 are:
1 2 26 48 40472
The factorions for base 12 are:
1 2

C

Translation of: Go

<lang c>#include <stdio.h>

int main() {

   int n, b, d;
   unsigned long long i, j, sum, fact[12];
   // cache factorials from 0 to 11
   fact[0] = 1;
   for (n = 1; n < 12; ++n) {
       fact[n] = fact[n-1] * n;
   }

   for (b = 9; b <= 12; ++b) {
       printf("The factorions for base %d are:\n", b);
       for (i = 1; i < 1500000; ++i) {
           sum = 0;
           j = i;
           while (j > 0) {
               d = j % b;
               sum += fact[d];
               j /= b;
           }
           if (sum == i) printf("%llu ", i);
       }
       printf("\n\n");
   }
   return 0;

}</lang>

Output:

The factorions for base 9 are:
1 2 41282 

The factorions for base 10 are:
1 2 145 40585 

The factorions for base 11 are:
1 2 26 48 40472 

The factorions for base 12 are:
1 2 

Factor

<lang factor>USING: formatting io kernel math math.parser math.ranges memoize prettyprint sequences ; IN: rosetta-code.factorions

! Memoize factorial function MEMO: factorial ( n -- n! ) [ 1 ] [ [1,b] product ] if-zero ;

factorion? ( n base -- ? )

   dupd >base string>digits [ factorial ] map-sum = ;

show-factorions ( limit base -- )

   dup "The factorions for base %d are:\n" printf
   [ [1,b) ] dip [ dupd factorion? [ pprint bl ] [ drop ] if ]
   curry each nl ;

1,500,000 9 12 [a,b] [ show-factorions nl ] with each</lang>

Output:

The factorions for base 9 are:
1 2 41282 

The factorions for base 10 are:
1 2 145 40585 

The factorions for base 11 are:
1 2 26 48 40472 

The factorions for base 12 are:
1 2 

Go

<lang go>package main

import (

   "fmt"
   "strconv"

)

func main() {

   // cache factorials from 0 to 11
   var fact [12]uint64
   fact[0] = 1
   for n := uint64(1); n < 12; n++ {
       fact[n] = fact[n-1] * n
   }

   for b := 9; b <= 12; b++ {
       fmt.Printf("The factorions for base %d are:\n", b)
       for i := uint64(1); i < 1500000; i++ {
           digits := strconv.FormatUint(i, b)
           sum := uint64(0)
           for _, digit := range digits {
               if digit < 'a' {
                   sum += fact[digit-'0']
               } else {
                   sum += fact[digit+10-'a']
               }
           }
           if sum == i {
               fmt.Printf("%d ", i)
           }
       }
       fmt.Println("\n")
   }

}</lang>

Output:

The factorions for base 9 are:
1 2 41282 

The factorions for base 10 are:
1 2 145 40585 

The factorions for base 11 are:
1 2 26 48 40472 

The factorions for base 12 are:
1 2 

OCaml

Translation of: C

<lang ocaml>let () =

 (* cache factorials from 0 to 11 *)
 let fact = Array.make 12 0 in
 fact.(0) <- 1;
 for n = 1 to pred 12 do
   fact.(n) <- fact.(n-1) * n;
 done;

 for b = 9 to 12 do
   Printf.printf "The factorions for base %d are:\n" b;
   for i = 1 to pred 1_500_000 do
     let sum = ref 0 in
     let j = ref i in
     while !j > 0 do
       let d = !j mod b in
       sum := !sum + fact.(d);
       j := !j / b;
     done;
     if !sum = i then (print_int i; print_string " ")
   done;
   print_string "\n\n";
 done</lang>

Perl 6

Works with: Rakudo version 2019.07.1

<lang perl6>constant @f = 1, |[\*] 1..*;

constant $limit = 1500000;

for 9 .. 12 -> $b {

   say "\n\nFactorions in base $b:";

   for ^$b { if $_ == @f[$_] { print "$_ " } };

   hyper for 1 .. $limit div $b -> $i {
       my $sum;
       my $prod = $i * $b;

       for  $i.polymod($b xx *) {
           $sum += @f[$_];
           $sum = 0 and last if $sum > $prod
       }

       next if $sum == 0;

       print "{$sum + @f[$_]} " and last if $sum + @f[$_] == $prod + $_ for ^$b;
   }

}</lang>

Output:

Factorions in base 9:
1 2 41282

Factorions in base 10:
1 2 145 40585

Factorions in base 11:
1 2 26 48 40472

Factorions in base 12:
1 2

zkl

Translation of: C

<lang zkl>var facts=[0..12].pump(List,fcn(n){ (1).reduce(n,fcn(N,n){ N*n },1) }); #(1,1,2,6....) fcn factorions(base){

  foreach n in ([1..1_499_999]){
     sum,j := 0,n;
     while(j>0){

sum+=facts[j%base]; j/=base;

     }
     if(sum==n) print("  ",n)
  }
  println();

}</lang> <lang zkl>foreach n in ([9..12]){

  print("The factorions for base %2d are: ".fmt(n)); factorions(n);

}</lang>

Output:

The factorions for base  9 are:   1  2  41282
The factorions for base 10 are:   1  2  145  40585
The factorions for base 11 are:   1  2  26  48  40472
The factorions for base 12 are:   1  2