Rosetta Code

Factorions: Difference between revisions

Page Discussion

Factorions (view source)

Revision as of 11:21, 4 December 2023

33,423 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
(→‎{{header|Ruby}}: Added Ruby)
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(42 intermediate revisions by 25 users not shown)
Line 13:
 
 
It can be shown (see thetalk Wikipedia article belowpage) that no factorion in base '''10''' can exceed   '''1,499,999'''.
 
 
Line 29:
:* '''[[OEIS:A193163|OEIS:A193163 - Factorions in base n]]'''
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V fact = [1]
L(n) 1..11
fact.append(fact[n-1] * n)
 
L(b) 9..12
print(‘The factorions for base ’b‘ are:’)
L(i) 1..1'499'999
V fact_sum = 0
V j = i
L j > 0
V d = j % b
fact_sum += fact[d]
j I/= b
I fact_sum == i
print(i, end' ‘ ’)
print("\n")</syntaxhighlight>
 
{{out}}
<pre>
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
 
</pre>
 
=={{header|360 Assembly}}==
<langsyntaxhighlight lang="360asm">* Factorions 26/04/2020
FACTORIO CSECT
USING FACTORIO,R13 base register
Line 91 ⟶ 127:
XDEC DS CL12 temp fo xdeco
REGEQU
END FACTORIO </langsyntaxhighlight>
{{out}}
<pre>
Line 99 ⟶ 135:
Base 12 : 1 2
</pre>
 
 
=={{header|ALGOL 68}}==
{{trans|C}}
<langsyntaxhighlight lang="algol68">BEGIN
# cache factorials from 0 to 11 #
[ 0 : 11 ]INT fact;
Line 123 ⟶ 158:
print( ( newline ) )
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 135 ⟶ 170:
1 2</pre>
 
=={{header|Applesoft BASICArturo}}==
 
<lang basic>100 DIM FACT(12)
<syntaxhighlight lang="rebol">factorials: [1 1 2 6 24 120 720 5040 40320 362880 3628800 39916800]
110 FACT(0) = 1
 
120 FOR N = 1 TO 11
factorion?: function [n, base][
130 FACT(N) = FACT(N - 1) * N
try? [
140 NEXT
n = sum map digits.base:base n 'x -> factorials\[x]
200 FOR B = 9 TO 12
]
210 PRINT "THE FACTORIONS ";
else [
215 PRINT "FOR BASE "B" ARE:"
220 FOR I = 1print TO["n:" 1499999n "base:" base]
230 SUM = 0false
]
240 FOR J = I TO 0 STEP 0
]
245 M = INT (J / B)
 
250 D = J - M * B
loop 9..12 'base ->
260 SUM = SUM + FACT(D)
print ["Base" base "factorions:" select 1..45000 'z -> factorion? z base]
270 J = M
]</syntaxhighlight>
280 NEXT J
 
290 IF SU = I THEN PRINT I" ";
{{out}}
300 NEXT I
 
310 PRINT : PRINT
<pre>Base 9 factorions: [1 2 41282]
320 NEXT B</lang>
Base 10 factorions: [1 2 145 40585]
Base 11 factorions: [1 2 26 48 40472]
Base 12 factorions: [1 2]</pre>
 
=={{header|AutoHotkey}}==
{{trans|C}}
<langsyntaxhighlight AutoHotkeylang="autohotkey">fact:=[]
fact[0] := 1
while (A_Index < 12)
Line 181 ⟶ 219:
}
MsgBox % res
return</langsyntaxhighlight>
{{out}}
<pre>
Line 190 ⟶ 228:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FACTORIONS.AWK
# converted from C
Line 216 ⟶ 254:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 224 ⟶ 262:
base 12 factorions: 1 2
</pre>
 
=={{header|BASIC}}==
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="basic">100 DIM FACT(12)
110 FACT(0) = 1
120 FOR N = 1 TO 11
130 FACT(N) = FACT(N - 1) * N
140 NEXT
200 FOR B = 9 TO 12
210 PRINT "THE FACTORIONS ";
215 PRINT "FOR BASE "B" ARE:"
220 FOR I = 1 TO 1499999
230 SUM = 0
240 FOR J = I TO 0 STEP 0
245 M = INT (J / B)
250 D = J - M * B
260 SUM = SUM + FACT(D)
270 J = M
280 NEXT J
290 IF SU = I THEN PRINT I" ";
300 NEXT I
310 PRINT : PRINT
320 NEXT B</syntaxhighlight>
 
=={{header|C}}==
{{trans|Go}}
<langsyntaxhighlight lang="c">#include <stdio.h>
 
int main() {
Line 253 ⟶ 314:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 272 ⟶ 333:
=={{header|C++}}==
{{trans|C}}
<langsyntaxhighlight lang="cpp">#include <iostream>
 
class factorion_t {
Line 303 ⟶ 364:
}
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>factorions for base 9: 1 2 41282
Line 309 ⟶ 370:
factorions for base 11: 1 2 26 48 40472
factorions for base 12: 1 2
</pre>
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(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 "~%")))</syntaxhighlight>
 
{{Out}}
<pre>In base 9 there are 3 factorions:
1 (decimal 1)
2 (decimal 2)
62558 (decimal 41282)
 
In base 10 there are 4 factorions:
1
2
145
40585
 
In base 11 there are 5 factorions:
1 (decimal 1)
2 (decimal 2)
24 (decimal 26)
44 (decimal 48)
28453 (decimal 40472)
 
In base 12 there are 2 factorions:
1 (decimal 1)
2 (decimal 2)
</pre>
 
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|C}}
<syntaxhighlight lang="delphi">
program Factorions;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils;
 
begin
var fact: TArray<UInt64>;
SetLength(fact, 12);
 
fact[0] := 0;
for var n := 1 to 11 do
fact[n] := fact[n - 1] * n;
 
for var b := 9 to 12 do
begin
writeln('The factorions for base ', b, ' are:');
for var i := 1 to 1499999 do
begin
var sum := 0;
var j := i;
while j > 0 do
begin
var d := j mod b;
sum := sum + fact[d];
j := j div b;
end;
if sum = i then
writeln(i, ' ');
end;
writeln(#10);
end;
readln;
end.</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Factorians. Nigel Galloway: October 22nd., 2021
let N=[|let mutable n=1 in yield n; for g in 1..11 do n<-n*g; yield n|]
let fG n g=let rec fN g=function i when i<n->g+N.[i] |i->fN(g+N.[i%n])(i/n) in fN 0 g
{9..12}|>Seq.iter(fun n->printf $"In base %d{n} Factorians are:"; {1..1500000}|>Seq.iter(fun g->if g=fG n g then printf $" %d{g}"); printfn "")
</syntaxhighlight>
{{out}}
<pre>In base 9 Factorians are: 1 2 41282
In base 10 Factorians are: 1 2 145 40585
In base 11 Factorians are: 1 2 26 48 40472
In base 12 Factorians are: 1 2
</pre>
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.parser math.ranges memoize
prettyprint sequences ;
IN: rosetta-code.factorions
Line 327 ⟶ 499:
curry each nl ;
 
1,500,000 9 12 [a,b] [ show-factorions nl ] with each</langsyntaxhighlight>
{{out}}
<pre>
Line 345 ⟶ 517:
=={{header|Fōrmulæ}}==
 
In [{{FormulaeEntry|page=https://wiki.formulae.org/?script=examples/Factorions this] page you can see the solution of this task.}}
 
'''Solution'''
 
Definitions:
 
[[File:Fōrmulæ - Factorions 01.png]]
 
[[File:Fōrmulæ - Factorions 02.png]]
 
The following calculates factorion lists from bases 9 to 12, with a limit of 1,499,999
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text ([http://wiki.formulae.org/Editing_F%C5%8Drmul%C3%A6_expressions more info]). Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for transportation effects more than visualization and edition.
 
[[File:Fōrmulæ - Factorions 03.png]]
The option to show Fōrmulæ programs and their results is showing images. Unfortunately images cannot be uploaded in Rosetta Code.
 
[[File:Fōrmulæ - Factorions 04.png]]
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">Dim As Integer fact(12), suma, d, j
fact(0) = 1
For n As Integer = 1 To 11
Line 372 ⟶ 553:
Print : Print
Next b
Sleep</langsyntaxhighlight>
{{out}}
<pre>
Line 389 ⟶ 570:
 
=={{header|Frink}}==
<langsyntaxhighlight lang="frink">factorion[n, base] := sum[map["factorial", integerDigits[n, base]]]
 
for base = 9 to 12
Line 396 ⟶ 577:
if n == factorion[n, base]
println["$base\t$n"]
}</langsyntaxhighlight>
 
{{out}}
Line 416 ⟶ 597:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 449 ⟶ 630:
fmt.Println("\n")
}
}</langsyntaxhighlight>
 
{{out}}
Line 466 ⟶ 647:
</pre>
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
import Data.List (unfoldr)
import Control.Monad (guard)
Line 480 ⟶ 661:
where
factorions b = filter (factorion b) [1..]
result n = show . take n . factorions</langsyntaxhighlight>
{{out}}
<pre>
Line 490 ⟶ 671:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang J>
index=: $ #: I.@:,
factorion=: 10&$: :(] = [: +/ [: ! #.^:_1)&>
Line 496 ⟶ 677:
FACTORIONS=: 9 0 +"1 index Q=: 9 10 11 12 factorion/ i. 1500000
 
NB. columns: base, factorion expressed in basesbase 10, andfactorion in base
(,. ".@:((Num_j_,26}.Alpha_j_) {~ #.inv/)"1) FACTORIONS
9 1 1
Line 519 ⟶ 700:
11 5
12 2
</syntaxhighlight>
</lang>
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">
public class Factorion {
public static void main(String [] args){
Line 595 ⟶ 776:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 606 ⟶ 787:
Base 12:
1 2
</pre>
 
=={{header|jq}}==
{{works with|jq}}
'''Also works with gojq, the Go implementation of jq, and with fq.'''
 
The main difficulty in computing the factorions of an arbitrary base
is obtaining a tight limit on the maximum value a factorion can
have in that base. The present entry accordingly does at least provide a function,
`sufficient`, for computing an upper bound with respect to a particular base, and uses it to compute
the factorions of all bases from 2 through 9.
 
However, the algorithm used by `sufficient` is too simplistic to be of much practical use for bases 10 or higher.
For base 10, the task description provides a value with a link to a justification. For bases 11 and 12, we use limits that are known to be sufficient, as per (*) [https://web.archive.org/web/20151220095834/https://en.wikipedia.org/wiki/Factorion].
 
<syntaxhighlight lang=jq>
# A stream of factorials
# [N|factorials][n] is n!
def factorials:
select(. > 0)
| 1,
foreach range(1; .) as $n(1; . * $n);
 
# The base-$b factorions less than or equal to $max
def factorions($b; $max):
($max // 1500000) as $max
| [$b|factorials] as $fact
| range(1; $max) as $i
| {sum: 0, j: $i}
| until( .j == 0 or .sum > $i;
( .j % $b) as $d
| .sum += $fact[$d]
| .j = ((.j/$b)|floor) )
| select(.sum == $i)
| $i ;
 
# input: base
# output: an upper bound for the factorions in that base
def sufficient:
. as $base
| [12|factorials] as $fact
| $fact[$base-1] as $f
| { digits: 1, value: $base}
| until ( (.value > ($f * .digits) );
.digits += 1
| .value *= $base ) ;
 
# Show the factorions for all based from 2 through 12:
(range(2;10)
| . as $base
| sufficient.value as $max
| {$base, factorions: ([factorions($base; $max)] | join(" "))}),
{base: 10, factorions: ([factorions(10; 1500000)] | join(" "))}, # limit per the task description
{base: 11, factorions: ([factorions(11; 50000)] | join(" "))}, # a limit known to be sufficient per (*)
{base: 12, factorions: ([factorions(12; 50000)] | join(" "))} # a limit known to be sufficient per (*)
 
</syntaxhighlight>
{{output}}
<pre>
{"base":2,"factorions":"1 2"}
{"base":3,"factorions":"1 2"}
{"base":4,"factorions":"1 2 7"}
{"base":5,"factorions":"1 2 49"}
{"base":6,"factorions":"1 2 25 26"}
{"base":7,"factorions":"1 2"}
{"base":8,"factorions":"1 2"}
{"base":9,"factorions":"1 2 41282"}
{"base":10,"factorions":"1 2 145 40585"}
{"base":11,"factorions":"1 2 26 48 40472"}
{"base":12,"factorions":"1 2"}
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">isfactorian(n, base) = mapreduce(factorial, +, map(c -> parse(Int, c, base=16), split(string(n, base=base), ""))) == n
 
printallfactorian(base) = println("Factorians for base $base: ", [n for n in 1:100000 if isfactorian(n, base)])
 
foreach(printallfactorian, 9:12)
</langsyntaxhighlight>{{out}}
<pre>
Factorians for base 9: [1, 2, 41282]
Line 621 ⟶ 872:
Factorians for base 12: [1, 2]
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
 
{def facts
{S.first
{S.map {{lambda {:a :i}
{A.addlast! {* {A.get {- :i 1} :a} :i} :a}
} {A.new 1}}
{S.serie 1 11}}}}
-> facts
 
{def sumfacts
{def sumfacts.r
{lambda {:base :sum :i}
{if {> :i 0}
then {sumfacts.r :base
{+ :sum {A.get {% :i :base} {facts}}}
{floor {/ :i :base}}}
else :sum }}}
{lambda {:base :n}
{sumfacts.r :base 0 :n}}}
-> sumfacts
 
{def show
{lambda {:base}
{S.replace \s by space in
{S.map {{lambda {:base :i}
{if {= {sumfacts :base :i} :i} then :i else}
} :base}
{S.serie 1 50000}}}}}
-> show
 
{S.map {lambda {:base}
{div}factorions for base :base: {show :base}}
9 10 11 12}
->
factorions for base 9: 1 2 41282
factorions for base 10: 1 2 145 40585
factorions for base 11: 1 2 26 48 40472
factorions for base 12: 1 2
 
</syntaxhighlight>
 
=={{header|Lang}}==
{{trans|Python}}
<syntaxhighlight lang="lang">
# Enabling raw variable names boosts the performance massivly [DO NOT RUN WITHOUT enabling raw variable names]
lang.rawVariableNames = 1
 
# Cache factorials from 0 to 11
&fact = fn.listOf(1)
$n = 1
while($n < 12) {
&fact += &fact[-|$n] * $n
$n += 1
}
 
$b = 9
while($b <= 12) {
fn.printf(The factorions for base %d are:%n, $b)
$i = 1
while($i < 1500000) {
$sum = 0
$j = $i
while($j > 0) {
$d $= $j % $b
$sum += &fact[$d]
$j //= $b
}
if($sum == $i) {
fn.print($i\s)
}
$i += 1
}
fn.println(\n)
$b += 1
}
</syntaxhighlight>
{{out}}
<pre>
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
 
</pre>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[FactorionQ]
FactorionQ[n_,b_:10]:=Total[IntegerDigits[n,b]!]==n
Select[Range[1500000],FactorionQ[#,9]&]
Select[Range[1500000],FactorionQ[#,10]&]
Select[Range[1500000],FactorionQ[#,11]&]
Select[Range[1500000],FactorionQ[#,12]&]</syntaxhighlight>
{{out}}
<pre>{1, 2, 41282}
{1, 2, 145, 40585}
{1, 2, 26, 48, 40472}
{1, 2}</pre>
 
=={{header|Nim}}==
Note that the library has precomputed the values of factorial, so there is no need for caching.
<syntaxhighlight lang="nim">from math import fac
from strutils import join
 
iterator digits(n, base: Natural): Natural =
## Yield the digits of "n" in base "base".
var n = n
while true:
yield n mod base
n = n div base
if n == 0: break
 
func isFactorion(n, base: Natural): bool =
## Return true if "n" is a factorion for base "base".
var s = 0
for d in n.digits(base):
inc s, fac(d)
result = s == n
 
func factorions(base, limit: Natural): seq[Natural] =
## Return the list of factorions for base "base" up to "limit".
for n in 1..limit:
if n.isFactorion(base):
result.add(n)
 
 
for base in 9..12:
echo "Factorions for base ", base, ':'
echo factorions(base, 1_500_000 - 1).join(" ")</syntaxhighlight>
 
{{out}}
<pre>Factorions for base 9:
1 2 41282
Factorions for base 10:
1 2 145 40585
Factorions for base 11:
1 2 26 48 40472
Factorions for base 12:
1 2</pre>
 
=={{header|OCaml}}==
{{trans|C}}
<langsyntaxhighlight lang="ocaml">let () =
(* cache factorials from 0 to 11 *)
let fact = Array.make 12 0 in
Line 645 ⟶ 1,051:
done;
print_string "\n\n";
done</langsyntaxhighlight>
=={{header|Pascal}}==
modified [[munchhausen numbers#Pascal]].
output in base and 0! == 1!, so in Base 10 40585 has the same digits as 14558.
<syntaxhighlight lang="pascal">program munchhausennumber;
{$IFDEF FPC}{$MODE objFPC}{$Optimization,On,all}{$ELSE}{$APPTYPE CONSOLE}{$ENDIF}
uses
sysutils;
type
tdigit = byte;
const
MAXBASE = 17;
 
var
DgtPotDgt : array[0..MAXBASE-1] of NativeUint;
dgtCnt : array[0..MAXBASE-1] of NativeInt;
cnt: NativeUint;
 
function convertToString(n:NativeUint;base:byte):AnsiString;
const
cBASEDIGITS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvxyz';
var
r,dgt: NativeUint;
begin
IF base > length(cBASEDIGITS) then
EXIT('Base to big');
result := '';
repeat
r := n div base;
dgt := n-r*base;
result := cBASEDIGITS[dgt+1]+result;
n := r;
until n =0;
end;
 
function CheckSameDigits(n1,n2,base:NativeUInt):boolean;
var
 
i : NativeUInt;
Begin
fillchar(dgtCnt,SizeOf(dgtCnt),#0);
repeat
//increment digit of n1
i := n1;n1 := n1 div base;i := i-n1*base;inc(dgtCnt[i]);
//decrement digit of n2
i := n2;n2 := n2 div base;i := i-n2*base;dec(dgtCnt[i]);
until (n1=0) AND (n2= 0);
result := true;
For i := 2 to Base-1 do
result := result AND (dgtCnt[i]=0);
result := result AND (dgtCnt[0]+dgtCnt[1]=0);
 
end;
 
procedure Munch(number,DgtPowSum,minDigit:NativeUInt;digits,base:NativeInt);
var
i: NativeUint;
s1,s2: AnsiString;
begin
inc(cnt);
number := number*base;
IF digits > 1 then
Begin
For i := minDigit to base-1 do
Munch(number+i,DgtPowSum+DgtPotDgt[i],i,digits-1,base);
end
else
For i := minDigit to base-1 do
//number is always the arrangement of the digits leading to smallest number
IF (number+i)<= (DgtPowSum+DgtPotDgt[i]) then
IF CheckSameDigits(number+i,DgtPowSum+DgtPotDgt[i],base) then
iF number+i>0 then
begin
s1 := convertToString(DgtPowSum+DgtPotDgt[i],base);
s2 := convertToString(number+i,base);
If length(s1)= length(s2) then
writeln(Format('%*d %*s %*s',[Base-1,DgtPowSum+DgtPotDgt[i],Base-1,s1,Base-1,s2]));
end;
end;
 
//factorions
procedure InitDgtPotDgt(base:byte);
var
i: NativeUint;
Begin
DgtPotDgt[0]:= 1;
For i := 1 to Base-1 do
DgtPotDgt[i] := DgtPotDgt[i-1]*i;
DgtPotDgt[0]:= 0;
end;
{
//Munchhausen numbers
procedure InitDgtPotDgt;
var
i,k,dgtpow: NativeUint;
Begin
// digit ^ digit ,special case 0^0 here 0
DgtPotDgt[0]:= 0;
For i := 1 to Base-1 do
Begin
dgtpow := i;
For k := 2 to i do
dgtpow := dgtpow*i;
DgtPotDgt[i] := dgtpow;
end;
end;
}
var
base : byte;
begin
cnt := 0;
For base := 2 to MAXBASE do
begin
writeln('Base = ',base);
InitDgtPotDgt(base);
Munch(0,0,0,base,base);
end;
writeln('Check Count ',cnt);
end.</syntaxhighlight>
{{out}}
<pre>
TIO.RUN Real time: 45.701 s User time: 44.968 s Sys. time: 0.055 s CPU share: 98.51 %
Base = 2
1 1 1
Base = 3
1 1 1
2 2 2
Base = 4
1 1 1
2 2 2
7 13 13
Base = 5
1 1 1
2 2 2
49 144 144
Base = 6
1 1 1
2 2 2
25 41 14
26 42 24
Base = 7
1 1 1
2 2 2
Base = 8
1 1 1
2 2 2
Base = 9
1 1 1
2 2 2
41282 62558 25568
Base = 10
1 1 1
2 2 2
145 145 145
40585 40585 14558
Base = 11
1 1 1
2 2 2
26 24 24
48 44 44
40472 28453 23458
Base = 12
1 1 1
2 2 2
Base = 13
1 1 1
2 2 2
519326767 83790C5B 135789BC
Base = 14
1 1 1
2 2 2
12973363226 8B0DD409C 11489BCDD
Base = 15
1 1 1
2 2 2
1441 661 166
1442 662 266
Base = 16
1 1 1
2 2 2
2615428934649 260F3B66BF9 1236669BBFF
Base = 17
1 1 1
2 2 2
40465 8405 1458
43153254185213 146F2G8500G4 111244568FGG
43153254226251 146F2G8586G4 124456688FGG
Check Count 1571990934
</pre>
 
=={{header|Perl}}==
===Raku version===
{{trans|Raku}}
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use ntheory qw/factorial todigits/;
Line 673 ⟶ 1,268:
}
print "\n\n";
}</langsyntaxhighlight>
{{out}}
<pre>Factorions in base 9:
Line 687 ⟶ 1,282:
1 2</pre>
 
===Sidef version===
Alternatively, a more efficient approach:
{{trans|Sidef}}
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use 5.020;
use ntheory qw(:all);
use experimental qw(signatures);
Line 726 ⟶ 1,322:
my @r = factorions($base);
say "Factorions in base $base are (@r)";
}</langsyntaxhighlight>
{{out}}
<pre>
Line 746 ⟶ 1,342:
=={{header|Phix}}==
{{trans|C}}
As per talk page (ok, ''and'' the task description), this is incorrectly using the base 10 limit for bases 9, 11, and 12.
<lang Phix>-- cache factorials from 0 to 11
<!--<syntaxhighlight lang="phix">(phixonline)-->
sequence fact = repeat(1,12)
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
for n=2 to length(fact) do
<span style="color: #008080;">for</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">=</span><span style="color: #000000;">9</span> <span style="color: #008080;">to</span> <span style="color: #000000;">12</span> <span style="color: #008080;">do</span>
fact[n] = fact[n-1]*(n-1)
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"The factorions for base %d are: "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
end for
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1499999</span> <span style="color: #008080;">do</span>
 
<span style="color: #004080;">atom</span> <span style="color: #000000;">total</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">d</span>
for b=9 to 12 do
<span style="color: #008080;">while</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">total</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">i</span> <span style="color: #008080;">do</span>
printf(1,"The factorions for base %d are:\n", b)
<span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">j</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
for i=1 to 1499999 do
<span style="color: #000000;">total</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">factorial</span><span style="color: #0000FF;">(</span><span style="color: #000000;">d</span><span style="color: #0000FF;">)</span>
atom total = 0, j = i, d
<span style="color: #000000;">j</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">j</span><span style="color: #0000FF;">/</span><span style="color: #000000;">base</span><span style="color: #0000FF;">)</span>
while j>0 and total<=i do
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
d = remainder(j,b)
<span style="color: #008080;">if</span> <span style="color: #000000;">total</span><span style="color: #0000FF;">==</span><span style="color: #000000;">i</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d "</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
total += fact[d+1]
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
j = floor(j/b)
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
end while
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
if total==i then printf(1,"%d ", i) end if
<!--</syntaxhighlight>-->
end for
printf(1,"\n\n")
end for</lang>
{{out}}
<pre>
The factorions for base 9 are: 1 2 41282
The factorions for base 10 are: 1 2 145 40585
1 2 41282
The factorions for base 11 are: 1 2 26 48 40472
The factorions for base 12 are: 1 2
</pre>
{{trans|Sidef}}
Using the correct limits and much faster, or at least it was until I upped the bases to 14.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">max_power</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">base</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">factorial</span><span style="color: #0000FF;">(</span><span style="color: #000000;">base</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">*</span><span style="color: #000000;">f</span> <span style="color: #0000FF;">>=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">m</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">digits</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0123456789abcd"</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">fcomb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">at</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">fsum</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">chosen</span><span style="color: #0000FF;">=</span><span style="color: #008000;">""</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">chosen</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">n</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">fs</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%a"</span><span style="color: #0000FF;">,{{</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fsum</span><span style="color: #0000FF;">}}))</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">fs</span><span style="color: #0000FF;">=</span><span style="color: #000000;">chosen</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fsum</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">else</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">at</span> <span style="color: #008080;">to</span> <span style="color: #000000;">base</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">fcomb</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fsum</span><span style="color: #0000FF;">+</span><span style="color: #7060A8;">factorial</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span><span style="color: #000000;">chosen</span><span style="color: #0000FF;">&</span><span style="color: #000000;">digits</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">factorions</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">base</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">result</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">max_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">base</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">result</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">fcomb</span><span style="color: #0000FF;">({},</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">result</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">base</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">14</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Base %2d factorions: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">base</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">factorions</span><span style="color: #0000FF;">(</span><span style="color: #000000;">base</span><span style="color: #0000FF;">))})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Base 2 factorions: 1 2
Base 3 factorions: 1 2
Base 4 factorions: 1 2 7
Base 5 factorions: 1 2 49
Base 6 factorions: 1 2 25 26
Base 7 factorions: 1 2
Base 8 factorions: 1 2
Base 9 factorions: 1 2 41282
Base 10 factorions: 1 2 145 40585
Base 11 factorions: 1 2 26 48 40472
Base 12 factorions: 1 2
Base 13 factorions: 1 2 519326767
Base 14 factorions: 1 2 12973363226
</pre>
It will in fact go all the way to 17, though I don't recommend it:
<pre>
Base 15 factorions: 1 2 1441 1442
Base 16 factorions: 1 2 2615428934649
Base 17 factorions: 1 2 40465 43153254185213 43153254226251
</pre>
 
=={{header|PureBasic}}==
The factorions for base 10 are:
{{trans|C}}
1 2 145 40585
<syntaxhighlight lang="purebasic">Declare main()
 
If OpenConsole() : main() : Else : End 1 : EndIf
The factorions for base 11 are:
Input() : End
1 2 26 48 40472
 
Procedure main()
The factorions for base 12 are:
Define.i n,b,d,i,j,sum
1 2
Dim fact.i(12)
</pre>
fact(0)=1
For n=1 To 11 : fact(n)=fact(n-1)*n : Next
For b=9 To 12
PrintN("The factorions for base "+Str(b)+" are: ")
For i=1 To 1500000-1
sum=0 : j=i
While j>0
d=j%b : sum+fact(d) : j/b
Wend
If sum=i : Print(Str(i)+" ") : EndIf
Next
Print(~"\n\n")
Next
EndProcedure</syntaxhighlight>
{{out}}
<pre>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 </pre>
 
=={{header|Python}}==
{{trans|C}}
<langsyntaxhighlight Pythonlang="python">fact = [1] # cache factorials from 0 to 11
for n in range(1, 12):
fact.append(fact[n-1] * n)
Line 788 ⟶ 1,477:
for b in range(9, 12+1):
print(f"The factorions for base {b} are:")
for i in range(1, 1500000):
fact_sum = 0
j = i
Line 797 ⟶ 1,486:
if fact_sum == i:
print(i, end=" ")
print("\n")
</syntaxhighlight>
</lang>
 
{{out}}
Line 813 ⟶ 1,502:
The factorions for base 12 are:
1 2
</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ table ] is results ( n --> s )
4 times
[ ' [ stack [ ] ]
copy
' results put ]
 
[ results dup take
rot join swap put ] is addresult ( n n --> )
 
[ table 9 10 11 12 ] is radix ( n --> n )
 
[ table 1 ] is ! ( n --> n )
1 11 times
[ i^ 1+ * dup
' ! put ]
drop
[ dip dup
0 temp put
[ tuck /mod !
temp tally
swap over 0 =
until ]
2drop
temp take = ] is factorion ( n n --> b )
 
1500000 times
[ i^ 4 times
[ dup
i^ radix
factorion if
[ dup i^
addresult ] ]
drop ]
4 times
[ say "Factorions for base "
i^ radix echo say ": "
i^ results take echo cr ]</syntaxhighlight>
 
{{out}}
 
<pre>Factorions for base 9: [ 1 2 41282 ]
Factorions for base 10: [ 1 2 145 40585 ]
Factorions for base 11: [ 1 2 26 48 40472 ]
Factorions for base 12: [ 1 2 ]
</pre>
 
Line 819 ⟶ 1,557:
 
{{trans|C}}
<langsyntaxhighlight lang="racket">#lang racket
 
(define fact
Line 833 ⟶ 1,571:
[(positive? n) (loop (+ sum (fact (modulo n b))) (quotient n b))]
[(= sum i) (printf "~a " i)])))
(newline))</langsyntaxhighlight>
 
{{out}}
Line 851 ⟶ 1,589:
{{works with|Rakudo|2019.07.1}}
 
<syntaxhighlight lang="raku" perl6line>constant @factorial = 1, |[\*] 1..*;
 
constant $limit = 1500000;
Line 859 ⟶ 1,597:
my @result;
 
$bases.race(:1batch).map: -> $base {
 
@result[$base] = "\nFactorions in base $base:\n1 2";
Line 883 ⟶ 1,621:
}
 
.say for @result[$bases];</langsyntaxhighlight>
{{out}}
<pre>Factorions in base 9:
Line 899 ⟶ 1,637:
=={{header|REXX}}==
{{trans|C}}
<langsyntaxhighlight lang="rexx">/*REXX program calculates and displays factorions in bases nine ───► twelve. */
parse arg LOb HIb lim . /*obtain optional arguments from the CL*/
if LOb=='' | LOb=="," then LOb= 9 /*Not specified? Then use the default.*/
Line 923 ⟶ 1,661:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
!: procedure; parse arg x; !=1; do j=2 to x; !=!*j; end; return ! /*factorials*/</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 935 ⟶ 1,673:
</pre>
 
=={{header|RingRPL}}==
{{trans|C}}
<lang Ring>
{{works with|Halcyon Calc|4.2.7}}
load "stdlib.ring"
{| class="wikitable"
 
! Code
for n = 1 to 100000
! Comments
fac = 0
|-
numStr = string(n)
|
for m = 1 to len(numStr)
≪
num = number(numStr[m])
{ } 1 11 '''FOR''' facn =n facFACT + factorial(num)'''NEXT''' → base fact
≪ { } 1 1500000 '''FOR''' n
next
if 0 n ='''WHILE''' facDUP '''REPEAT'''
see "Factorion: " + n +fact OVER base MOD 1 MAX GET nl
ROT + SWAP
ok
base / IP
next
'''END''' DROP
</lang>
'''IF''' n == '''THEN''' n + '''END'''
'''NEXT'''
≫ ≫ ‘FTRION’ STO
|
''( base -- { factorions } )''
Cache 1! to 11!
Loop until all digits scanned
Get (last digit)! even if last digit = 0
Add to sum of digits
prepare next loop
Store factorion
|}
The following lines of command deliver what is required:
9 FTRION
10 FTRION
11 FTRION
12 FTRION
{{out}}
<pre>
4: { 1 2 41282 }
Factorion: 1
3: { 1 2 145 40585 }
Factorion: 2
2: { 1 2 26 48 40472 }
Factorion: 145
1: { 1 2 }
Factorion: 40585
</pre>
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">
def factorion?(n, base)
n.digits(base).sum{|digit| (1..digit).inject(1, :*)} == n
Line 966 ⟶ 1,727:
puts "Base #{base} factorions: #{(1..1_500_000).select{|n| factorion?(n, base)}.join(" ")} "
end
</syntaxhighlight>
</lang>
{{out}}
<pre>Base 9 factorions: 1 2 41282
Line 976 ⟶ 1,737:
=={{header|Scala}}==
{{trans|C++}}
<langsyntaxhighlight lang="scala">object Factorion extends App {
private def is_factorion(i: Int, b: Int): Boolean = {
var sum = 0L
Line 995 ⟶ 1,756:
println
})
}</langsyntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func max_power(b = 10) {
var m = 1
var f = (b-1)!
Line 1,028 ⟶ 1,789:
var r = factorions(b)
say "Base #{'%2d' % b} factorions: #{r}"
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,045 ⟶ 1,806:
 
=={{header|Swift}}==
 
{{trans|C}}
<syntaxhighlight lang="swift">var fact = Array(repeating: 0, count: 12)
 
<lang swift>var fact = Array(repeating: 0, count: 12)
 
fact[0] = 1
Line 1,075 ⟶ 1,834:
 
print("\n")
}</langsyntaxhighlight>
 
{{out}}
Line 1,091 ⟶ 1,850:
1 2</pre>
 
=={{header|WrenuBasic/4tH}}==
{{trans|CFreeBASIC}}
It will take some time, but it will get there.
<lang ecmascript>// cache factorials from 0 to 11
<syntaxhighlight lang="uBasic/4tH">Dim @f(12)
var fact = List.filled(12, 0)
fact[0] = 1
for (n in 1..11) fact[n] = fact[n-1] * n
 
@f(0) = 1: For n = 1 To 11 : @f(n) = @f(n-1) * n : Next
for (b in 9..12) {
 
System.print("The factorions for base %(b) are:")
For b = 9 To 12
for (i in 1...1500000) {
Print "The factorions for base ";b;" are: "
var sum = 0
For i = 1 To var j = i1499999
s while (j >= 0) {
var dj = j % bi
Do While j > 0
sum = sum + fact[d]
d = j =% (j/b).floor
s = s + @f(d)
j = j / b
Loop
If s = i Then Print i;" ";
Next
Print : Print
Next</syntaxhighlight>
{{Out}}
<pre>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
 
 
0 OK, 0:379</pre>
 
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import strconv
 
fn main() {
// cache factorials from 0 to 11
mut fact := [12]u64{}
fact[0] = 1
for n := u64(1); n < 12; n++ {
fact[n] = fact[n-1] * n
}
for b := 9; b <= 12; b++ {
println("The factorions for base $b are:")
for i := u64(1); i < 1500000; i++ {
digits := strconv.format_uint(i, b)
mut sum := u64(0)
for digit in digits {
if digit < `a` {
sum += fact[digit-`0`]
} else {
sum += fact[digit+10-`a`]
}
}
if sum == i {
print("$i ")
}
}
if (sum == i) System.writeprintln("%(i) \n")
}
}</syntaxhighlight>
System.print("\n")
}</lang>
 
{{out}}
Line 1,125 ⟶ 1,931:
 
The factorions for base 12 are:
1 2
</pre>
 
=={{header|VBScript}}==
<langsyntaxhighlight lang="vb">' Factorions - VBScript - PG - 26/04/2020
Dim fact()
nn1=9 : nn2=12
Line 1,151 ⟶ 1,957:
Next
Wscript.Echo "the factorions for base "& right(" "& base,2) &" are: "& list
Next </langsyntaxhighlight>
{{out}}
<pre>
Line 1,160 ⟶ 1,966:
</pre>
 
=={{header|Wren}}==
{{trans|C}}
<syntaxhighlight lang="wren">// cache factorials from 0 to 11
var fact = List.filled(12, 0)
fact[0] = 1
for (n in 1..11) fact[n] = fact[n-1] * n
 
for (b in 9..12) {
System.print("The factorions for base %(b) are:")
for (i in 1...1500000) {
var sum = 0
var j = i
while (j > 0) {
var d = j % b
sum = sum + fact[d]
j = (j/b).floor
}
if (sum == i) System.write("%(i) ")
}
System.print("\n")
}</syntaxhighlight>
 
{{out}}
<pre>
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
</pre>
 
=={{header|XPL0}}==
{{trans|C}}
<syntaxhighlight lang "XPL0">int N, Base, Digit, I, J, Sum, Factorial(12);
[Factorial(0):= 1; \cache factorials from 0 to 11
for N:= 1 to 12-1 do
Factorial(N):= Factorial(N-1)*N;
for Base:= 9 to 12 do
[Text(0, "The factorions for base "); IntOut(0, Base); Text(0, " are:^m^j");
for I:= 1 to 1_499_999 do
[Sum:= 0;
J:= I;
while J > 0 do
[Digit:= rem(J/Base);
Sum:= Sum + Factorial(Digit);
J:= J/Base;
];
if Sum = I then [IntOut(0, I); ChOut(0, ^ )];
];
CrLf(0); CrLf(0);
];
]</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|zkl}}==
{{trans|C}}
<langsyntaxhighlight 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){
fs:=List();
Line 1,175 ⟶ 2,053:
}
fs
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">foreach n in ([9..12]){
println("The factorions for base %2d are: ".fmt(n),factorions(n).concat(" "));
}</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,482

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/292447...353867"