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

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 

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

<lang zkl></lang> <lang zkl></lang>

Output: