Rosetta Code

Special factorials: Difference between revisions

Page Discussion

Special factorials (view source)

Revision as of 12:45, 23 February 2024

63,310 bytes added ,  2 months ago
→‎Add missing solutions
(→‎{{header|Factor}}: speed up digit counting)
 
(45 intermediate revisions by 23 users not shown)
Line 34:
* Show   rf(119).   The result should be undefined.
<br />
 
;Notes
: Since the factorial inverse of &nbsp; '''1''' &nbsp; is both &nbsp; 0 &nbsp; and &nbsp; 1, &nbsp; your function should return &nbsp; '''0''' &nbsp; in this case since it is normal to use the first match found in a series.
<br />
 
;See also
* [[Factorial]]
Line 44 ⟶ 49:
<br />
<br />
=={{header|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F sf(n)
V result = BigInt(1)
L(i) 2 .. n
result *= factorial(i)
R result
 
F hf(n)
V result = BigInt(1)
L(i) 2 .. n
result *= pow(BigInt(i), i)
R result
 
F af(n)
V result = BigInt(0)
V m = ((n [&] 1) << 1) - 1
L(i) 1 .. n
result += m * factorial(i)
m = -m
R result
 
F ef(n)
V result = BigInt(1)
L(k) 2 .. n
result = pow(k, result)
R result
 
F rf(n)
I n == 1
R 0
V result = 1
V p = 1
L p < n
result++
p *= result
I p > n
result = -1
R result
 
V sfs = (0.<10).map(n -> sf(n))
print(‘First ’sfs.len‘ superfactorials: ’sfs.join(‘ ’))
 
V hfs = (0.<10).map(n -> hf(n))
print(‘First ’hfs.len‘ hyperfactorials: ’hfs.join(‘ ’))
 
V afs = (0.<10).map(n -> af(n))
print(‘First ’afs.len‘ alternating factorials: ’afs.join(‘ ’))
 
V efs = (0.<5).map(n -> ef(n))
print(‘First ’efs.len‘ exponential factorials: ’efs.join(‘ ’))
 
print("\nNumber of digits of ef(5): "String(ef(5)).len)
 
print("\nReverse factorials:")
L(n) [1, 2, 6, 24, 119, 120, 720, 5040, 40320, 362880, 3628800]
V r = rf(n)
print(f:‘{n:7}: {I r >= 0 {f:‘{r:2}’} E ‘undefined’}’)</syntaxhighlight>
 
{{out}}
<pre>
First 10 superfactorials: 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
First 10 hyperfactorials: 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
First 10 alternating factorials: 0 1 1 5 19 101 619 4421 35899 326981
First 5 exponential factorials: 1 1 2 9 262144
 
Number of digits of ef(5): 183231
 
Reverse factorials:
1: 0
2: 2
6: 3
24: 4
119: undefined
120: 5
720: 6
5040: 7
40320: 8
362880: 9
3628800: 10
</pre>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses Algol 68G's LONG LONG INT with default precision, which is long enough for the values needed for the task, except exponential factorial( 5 ).
The reverse factorial function uses a UNION(INT,STRING) for the result, so the result can either be an integer or the string "undefined".
<syntaxhighlight lang="algol68">
BEGIN # show the values of some "special factorials" #
 
# super factorial: returns the product of the factorials up to to n #
PROC sf = ( INT n )LONG LONG INT:
BEGIN
LONG LONG INT f := 1, p := 1;
FOR i TO n DO
f *:= i;
p *:= f
OD;
p
END # sf # ;
# hyper factorial: returns the product of k^k for k up to n #
PROC hf = ( INT n )LONG LONG INT:
BEGIN
LONG LONG INT p := 1;
FOR i TO n DO
TO i DO p *:= i OD
OD;
p
END # hf # ;
# alternating factorial: returns the sum of (-1)^(i-1)*i! for i up to n #
PROC af = ( INT n )LONG LONG INT:
BEGIN
LONG LONG INT s := 0;
LONG LONG INT f := 1;
INT sign := IF ODD n THEN 1 ELSE - 1 FI;
FOR i TO n DO
f *:= i;
s +:= sign * f;
sign := - sign
OD;
s
END # hf # ;
# exponential factorial: returns n^(n-1)^(n-2)... #
PROC xf = ( INT n )LONG LONG INT:
BEGIN
LONG LONG INT x := 1;
FOR i TO n DO
LONG LONG INT ix := 1;
TO SHORTEN SHORTEN x DO ix *:= i OD;
x := ix
OD;
x
END # hf # ;
# reverse factorial: returns k if n = k! for some integer k #
# "undefined" otherwise #
PROC rf = ( LONG LONG INT n )UNION( INT, STRING ):
IF n < 2
THEN 0
ELSE
LONG LONG INT f := 1;
INT i := 1;
WHILE f < n DO
f *:= i;
i +:= 1
OD;
IF f = n THEN i - 1 ELSE "undefined" FI
FI # rf # ;
 
print( ( "super factorials 0..9:", newline, " " ) );
FOR i FROM 0 TO 9 DO print( ( " ", whole( sf( i ), 0 ) ) ) OD;
print( ( newline, "hyper factorials 0..9:", newline, " " ) );
FOR i FROM 0 TO 9 DO print( ( " ", whole( hf( i ), 0 ) ) ) OD;
print( ( newline, "alternating factorials 0..9:", newline, " " ) );
FOR i FROM 0 TO 9 DO print( ( " ", whole( af( i ), 0 ) ) ) OD;
print( ( newline, "exponential factorials 0..4:", newline, " " ) );
FOR i FROM 0 TO 4 DO print( ( " ", whole( xf( i ), 0 ) ) ) OD;
 
[]INT rf test = ( 1, 2, 6, 24, 119, 120, 720, 5040, 40320, 362880, 3628800 );
print( ( newline, "reverse factorials:", newline ) );
FOR i FROM LWB rf test TO UPB rf test DO
INT tv = rf test[ i ];
print( ( whole( tv, -8 )
, " -> "
, CASE rf( tv )
IN ( INT iv ): whole( iv, 0 )
, ( STRING sv ): sv
OUT "Unexpected value returned by rf( " + whole( tv, 0 ) + " )"
ESAC
, newline
)
)
OD
 
END
</syntaxhighlight>
{{out}}
<pre>
super factorials 0..9:
1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
hyper factorials 0..9:
1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
alternating factorials 0..9:
0 1 1 5 19 101 619 4421 35899 326981
exponential factorials 0..4:
1 1 2 9 262144
reverse factorials:
1 -> 0
2 -> 2
6 -> 3
24 -> 4
119 -> undefined
120 -> 5
720 -> 6
5040 -> 7
40320 -> 8
362880 -> 9
3628800 -> 10
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="arturo">super: $ => [fold.seed:1 1..& [x y] -> x * factorial y]
 
hyper: $ => [fold.seed:1 1..& [x y] -> x * y^y]
 
alternating: $[n][
fold 1..n [x y] ->
x + (factorial y) * (neg 1)^n-y
]
 
exponential: $ => [fold.seed:1 0..& [x y] -> y^x]
 
rf: function [n][
if 1 = n -> return 0
b: a: <= 1
while -> n > a [
'b + 1
'a * b
]
if a = n -> return b
return null
]
 
print "First 10 superfactorials:"
print map 0..9 => super
 
print "\nFirst 10 hyperfactorials:"
print map 0..9 => hyper
 
print "\nFirst 10 alternating factorials:"
print map 0..9 => alternating
 
print "\nFirst 5 exponential factorials:"
print map 0..4 => exponential
 
prints "\nNumber of digits in $5: "
print size ~"|exponential 5|"
print ""
 
[1 2 6 24 120 720 5040 40320 362880 3628800 119]
| loop 'x -> print ~"rf(|x|) = |rf x|"</syntaxhighlight>
 
{{out}}
 
<pre>First 10 superfactorials:
1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
 
First 10 hyperfactorials:
1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
 
First 10 alternating factorials:
0.0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials:
0 1 2 9 262144
 
Number of digits in $5: 183231
 
rf(1) = 0
rf(2) = 2
rf(6) = 3
rf(24) = 4
rf(120) = 5
rf(720) = 6
rf(5040) = 7
rf(40320) = 8
rf(362880) = 9
rf(3628800) = 10
rf(119) = null</pre>
 
=={{header|Bruijn}}==
 
Implementation for numbers encoded in balanced ternary using Mixfix syntax defined in the Math module:
 
<syntaxhighlight lang="bruijn">
:import std/Combinator .
:import std/List .
:import std/Math .
 
factorial [∏ (+1) → 0 | [0]]
 
superfactorial [∏ (+1) → 0 | factorial]
 
hyperfactorial [∏ (+1) → 0 | [0 ** 0]]
 
alternating-factorial y [[=?0 0 ((factorial 0) - (1 --0))]]
 
exponential-factorial y [[=?0 0 (0 ** (1 --0))]]
 
:test ((factorial (+4)) =? (+24)) ([[1]])
:test ((superfactorial (+4)) =? (+288)) ([[1]])
:test ((hyperfactorial (+4)) =? (+27648)) ([[1]])
:test ((alternating-factorial (+3)) =? (+5)) ([[1]])
:test ((exponential-factorial (+4)) =? (+262144)) ([[1]])
 
invfac y [[[compare-case 1 (2 ++1 0) (-1) 0 (∏ (+0) → --1 | ++‣)]]] (+0)
 
:test ((invfac (+1)) =? (+0)) ([[1]])
:test ((invfac (+2)) =? (+2)) ([[1]])
:test ((invfac (+6)) =? (+3)) ([[1]])
:test ((invfac (+24)) =? (+4)) ([[1]])
:test ((invfac (+120)) =? (+5)) ([[1]])
:test ((invfac (+720)) =? (+6)) ([[1]])
:test ((invfac (+5040)) =? (+7)) ([[1]])
:test ((invfac (+40320)) =? (+8)) ([[1]])
:test ((invfac (+362880)) =? (+9)) ([[1]])
:test ((invfac (+3628800)) =? (+10)) ([[1]])
:test ((invfac (+119)) =? (-1)) ([[1]])
 
seq-a [((superfactorial 0) : ((hyperfactorial 0) : {}(alternating-factorial 0)))] <$> (iterate ++‣ (+0))
 
seq-b exponential-factorial <$> (iterate ++‣ (+0))
 
# return first 10/4 elements of both sequences
main [(take (+10) seq-a) : {}(take (+5) seq-b)]
</syntaxhighlight>
 
=={{header|C}}==
<syntaxhighlight lang="c">#include <math.h>
#include <stdint.h>
#include <stdio.h>
 
/* n! = 1 * 2 * 3 * ... * n */
uint64_t factorial(int n) {
uint64_t result = 1;
int i;
 
for (i = 1; i <= n; i++) {
result *= i;
}
 
return result;
}
 
/* if(n!) = n */
int inverse_factorial(uint64_t f) {
int p = 1;
int i = 1;
 
if (f == 1) {
return 0;
}
 
while (p < f) {
p *= i;
i++;
}
 
if (p == f) {
return i - 1;
}
return -1;
}
 
/* sf(n) = 1! * 2! * 3! * ... . n! */
uint64_t super_factorial(int n) {
uint64_t result = 1;
int i;
 
for (i = 1; i <= n; i++) {
result *= factorial(i);
}
 
return result;
}
 
/* H(n) = 1^1 * 2^2 * 3^3 * ... * n^n */
uint64_t hyper_factorial(int n) {
uint64_t result = 1;
int i;
 
for (i = 1; i <= n; i++) {
result *= (uint64_t)powl(i, i);
}
 
return result;
}
 
/* af(n) = -1^(n-1)*1! + -1^(n-2)*2! + ... + -1^(0)*n! */
uint64_t alternating_factorial(int n) {
uint64_t result = 0;
int i;
 
for (i = 1; i <= n; i++) {
if ((n - i) % 2 == 0) {
result += factorial(i);
} else {
result -= factorial(i);
}
}
 
return result;
}
 
/* n$ = n ^ (n - 1) ^ ... ^ (2) ^ 1 */
uint64_t exponential_factorial(int n) {
uint64_t result = 0;
int i;
 
for (i = 1; i <= n; i++) {
result = (uint64_t)powl(i, (long double)result);
}
 
return result;
}
 
void test_factorial(int count, uint64_t(*func)(int), char *name) {
int i;
 
printf("First %d %s:\n", count, name);
for (i = 0; i < count ; i++) {
printf("%llu ", func(i));
}
printf("\n");
}
 
void test_inverse(uint64_t f) {
int n = inverse_factorial(f);
if (n < 0) {
printf("rf(%llu) = No Solution\n", f);
} else {
printf("rf(%llu) = %d\n", f, n);
}
}
 
int main() {
int i;
 
/* cannot display the 10th result correctly */
test_factorial(9, super_factorial, "super factorials");
printf("\n");
 
/* cannot display the 9th result correctly */
test_factorial(8, super_factorial, "hyper factorials");
printf("\n");
 
test_factorial(10, alternating_factorial, "alternating factorials");
printf("\n");
 
test_factorial(5, exponential_factorial, "exponential factorials");
printf("\n");
 
test_inverse(1);
test_inverse(2);
test_inverse(6);
test_inverse(24);
test_inverse(120);
test_inverse(720);
test_inverse(5040);
test_inverse(40320);
test_inverse(362880);
test_inverse(3628800);
test_inverse(119);
 
return 0;
}</syntaxhighlight>
{{out}}
<pre>First 9 super factorials:
1 1 2 12 288 34560 24883200 125411328000 5056584744960000
 
First 8 hyper factorials:
1 1 2 12 288 34560 24883200 125411328000
 
First 10 alternating factorials:
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials:
0 1 2 9 262144
 
rf(1) = 0
rf(2) = 2
rf(6) = 3
rf(24) = 4
rf(120) = 5
rf(720) = 6
rf(5040) = 7
rf(40320) = 8
rf(362880) = 9
rf(3628800) = 10
rf(119) = No Solution</pre>
 
=={{header|C++}}==
{{trans|C}}
<syntaxhighlight lang="cpp">#include <cmath>
#include <cstdint>
#include <iostream>
#include <functional>
 
/* n! = 1 * 2 * 3 * ... * n */
uint64_t factorial(int n) {
uint64_t result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
 
/* if(n!) = n */
int inverse_factorial(uint64_t f) {
int p = 1;
int i = 1;
 
if (f == 1) {
return 0;
}
 
while (p < f) {
p *= i;
i++;
}
 
if (p == f) {
return i - 1;
}
return -1;
}
 
/* sf(n) = 1! * 2! * 3! * ... . n! */
uint64_t super_factorial(int n) {
uint64_t result = 1;
for (int i = 1; i <= n; i++) {
result *= factorial(i);
}
return result;
}
 
/* H(n) = 1^1 * 2^2 * 3^3 * ... * n^n */
uint64_t hyper_factorial(int n) {
uint64_t result = 1;
for (int i = 1; i <= n; i++) {
result *= (uint64_t)powl(i, i);
}
return result;
}
 
/* af(n) = -1^(n-1)*1! + -1^(n-2)*2! + ... + -1^(0)*n! */
uint64_t alternating_factorial(int n) {
uint64_t result = 0;
for (int i = 1; i <= n; i++) {
if ((n - i) % 2 == 0) {
result += factorial(i);
} else {
result -= factorial(i);
}
}
return result;
}
 
/* n$ = n ^ (n - 1) ^ ... ^ (2) ^ 1 */
uint64_t exponential_factorial(int n) {
uint64_t result = 0;
for (int i = 1; i <= n; i++) {
result = (uint64_t)powl(i, (long double)result);
}
return result;
}
 
void test_factorial(int count, std::function<uint64_t(int)> func, const std::string &name) {
std::cout << "First " << count << ' ' << name << '\n';
for (int i = 0; i < count; i++) {
std::cout << func(i) << ' ';
}
std::cout << '\n';
}
 
void test_inverse(uint64_t f) {
int n = inverse_factorial(f);
if (n < 0) {
std::cout << "rf(" << f << ") = No Solution\n";
} else {
std::cout << "rf(" << f << ") = " << n << '\n';
}
}
 
int main() {
/* cannot display the 10th result correctly */
test_factorial(9, super_factorial, "super factorials");
std::cout << '\n';
 
/* cannot display the 9th result correctly */
test_factorial(8, hyper_factorial, "hyper factorials");
std::cout << '\n';
 
test_factorial(10, alternating_factorial, "alternating factorials");
std::cout << '\n';
 
test_factorial(5, exponential_factorial, "exponential factorials");
std::cout << '\n';
 
test_inverse(1);
test_inverse(2);
test_inverse(6);
test_inverse(24);
test_inverse(120);
test_inverse(720);
test_inverse(5040);
test_inverse(40320);
test_inverse(362880);
test_inverse(3628800);
test_inverse(119);
 
return 0;
}</syntaxhighlight>
{{out}}
<pre>First 9 super factorials
1 1 2 12 288 34560 24883200 125411328000 5056584744960000
 
First 8 hyper factorials
1 1 4 108 27648 86400000 4031078400000 3319766398771200000
 
First 10 alternating factorials
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials
0 1 2 9 262144
 
rf(1) = 0
rf(2) = 2
rf(6) = 3
rf(24) = 4
rf(120) = 5
rf(720) = 6
rf(5040) = 7
rf(40320) = 8
rf(362880) = 9
rf(3628800) = 10
rf(119) = No Solution</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.factorials math.functions
math.parser math.ranges prettyprint sequences sequences.extras ;
IN: rosetta-code.special-factorials
 
: sf ( n -- m ) [1..b] [ n! ] map-product ;
Line 55 ⟶ 689:
: $ ( n -- m ) [1..b] [ ] [ swap ^ ] map-reduce ;
 
: (rf) ( n -- m )
[ 1 1 ] dip [ dup reach > ]
[ [ 1 + [ * ] keep ] dip ] while swapd = swap and ;
 
: rf ( n -- m ) dup 1 = [ drop 0 ] [ (rf) ] if ;
 
: .show ( n quot -- )
Line 74 ⟶ 710:
5 [ $ ] .show nl
 
"Number of digits in $5$:" print
5 $ log10 >integer 1 + . nl
 
{ 1 2 6 24 120 720 5040 40320 362880 3628800 119 }
[ dup rf "rf(%d) = %u\n" printf ] each nl</langsyntaxhighlight>
{{out}}
<pre>
Line 93 ⟶ 729:
0 1 2 9 262144
 
Number of digits in $5$:
183231
 
rf(1) = 10
rf(2) = 2
rf(6) = 3
Line 108 ⟶ 744:
rf(119) = f
</pre>
 
=={{header|Fermat}}==
<syntaxhighlight lang="text">Function Sf(n) = Prod<k=1, n>[k!].
 
Function H(n) = Prod<k=1, n>[k^k].
 
Function Af(n) = Sigma<i=1,n>[(-1)^(n-i)i!].
 
Function Ef(n) = if n < 2 then 1 else n^Ef(n-1) fi.
 
Function Rf(n) =
for r = 1 to n do
rr:=r!;
if rr=n then Return(r) fi;
if rr>n then Return(-1) fi;
od.
 
for n=0 to 9 do !!(Sf(n), H(n), Af(n)) od;
!!' ';
for n=0 to 4 do !!Ef(n) od;
!!' ';
for n=1 to 10 do !!Rf(n!) od;
!!Rf(119)</syntaxhighlight>
 
=={{header|FreeBASIC}}==
Only goes up to H(7) due to overflow. Using a library with big int support is possible, but would only add bloat without being illustrative.
<syntaxhighlight lang="freebasic">function factorial(n as uinteger) as ulongint
if n<2 then return 1 else return n*factorial(n-1)
end function
 
function sf(n as uinteger) as ulongint
dim as ulongint p=1
for k as uinteger = 1 to n
p*=factorial(k)
next k
return p
end function
 
function H( n as uinteger ) as ulongint
dim as ulongint p=1
for k as uinteger = 1 to n
p*=k^k
next k
return p
end function
 
function af( n as uinteger ) as longint
dim as longint s=0
for i as uinteger = 1 to n
s += (-1)^(n-i)*factorial(i)
next i
return s
end function
 
function ef( n as uinteger ) as ulongint
if n<2 then return 1 else return n^ef(n-1)
end function
 
function rf( n as ulongint ) as integer
dim as uinteger r=0,rr
while true
rr=factorial(r)
if rr>n then return -1
if rr=n then return r
r+=1
wend
end function
 
for n as uinteger = 0 to 7
print sf(n), H(n), af(n)
next n
print
for n as uinteger = 0 to 4
print ef(n);" ";
next n
print : print
for n as uinteger =0 to 9
print rf(factorial(n));" ";
next n
print rf(119)</syntaxhighlight>
 
=={{header|Go}}==
{{trans|Wren}}
<syntaxhighlight lang="go">package main
 
import (
"fmt"
"math/big"
)
 
func sf(n int) *big.Int {
if n < 2 {
return big.NewInt(1)
}
sfact := big.NewInt(1)
fact := big.NewInt(1)
for i := 2; i <= n; i++ {
fact.Mul(fact, big.NewInt(int64(i)))
sfact.Mul(sfact, fact)
}
return sfact
}
 
func H(n int) *big.Int {
if n < 2 {
return big.NewInt(1)
}
hfact := big.NewInt(1)
for i := 2; i <= n; i++ {
bi := big.NewInt(int64(i))
hfact.Mul(hfact, bi.Exp(bi, bi, nil))
}
return hfact
}
 
func af(n int) *big.Int {
if n < 1 {
return new(big.Int)
}
afact := new(big.Int)
fact := big.NewInt(1)
sign := new(big.Int)
if n%2 == 0 {
sign.SetInt64(-1)
} else {
sign.SetInt64(1)
}
t := new(big.Int)
for i := 1; i <= n; i++ {
fact.Mul(fact, big.NewInt(int64(i)))
afact.Add(afact, t.Mul(fact, sign))
sign.Neg(sign)
}
return afact
}
 
func ef(n int) *big.Int {
if n < 1 {
return big.NewInt(1)
}
t := big.NewInt(int64(n))
return t.Exp(t, ef(n-1), nil)
}
 
func rf(n *big.Int) int {
i := 0
fact := big.NewInt(1)
for {
if fact.Cmp(n) == 0 {
return i
}
if fact.Cmp(n) > 0 {
return -1
}
i++
fact.Mul(fact, big.NewInt(int64(i)))
}
}
 
func main() {
fmt.Println("First 10 superfactorials:")
for i := 0; i < 10; i++ {
fmt.Println(sf(i))
}
 
fmt.Println("\nFirst 10 hyperfactorials:")
for i := 0; i < 10; i++ {
fmt.Println(H(i))
}
 
fmt.Println("\nFirst 10 alternating factorials:")
for i := 0; i < 10; i++ {
fmt.Print(af(i), " ")
}
 
fmt.Println("\n\nFirst 5 exponential factorials:")
for i := 0; i <= 4; i++ {
fmt.Print(ef(i), " ")
}
 
fmt.Println("\n\nThe number of digits in 5$ is", len(ef(5).String()))
 
fmt.Println("\nReverse factorials:")
facts := []int64{1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119}
for _, fact := range facts {
bfact := big.NewInt(fact)
rfact := rf(bfact)
srfact := fmt.Sprintf("%d", rfact)
if rfact == -1 {
srfact = "none"
}
fmt.Printf("%4s <- rf(%d)\n", srfact, fact)
}
}</syntaxhighlight>
 
{{out}}
<pre>
First 10 superfactorials:
1
1
2
12
288
34560
24883200
125411328000
5056584744960000
1834933472251084800000
 
First 10 hyperfactorials:
1
1
4
108
27648
86400000
4031078400000
3319766398771200000
55696437941726556979200000
21577941222941856209168026828800000
 
First 10 alternating factorials:
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials:
1 1 2 9 262144
 
The number of digits in 5$ is 183231
 
Reverse factorials:
0 <- rf(1)
2 <- rf(2)
3 <- rf(6)
4 <- rf(24)
5 <- rf(120)
6 <- rf(720)
7 <- rf(5040)
8 <- rf(40320)
9 <- rf(362880)
10 <- rf(3628800)
none <- rf(119)
</pre>
 
=={{header|jq}}==
{{trans|Wren}}
'''Works with gojq, the Go implementation of jq'''
 
The standard version of jq does not maintain integer precision sufficiently for
some of the specific tasks (some of the hyperfactorials and the computation of 5$)
but can otherwise be used.
<syntaxhighlight lang="jq">
# for integer precision:
def power($b): . as $a | reduce range(0;$b) as $i (1; . * $a);
 
def sf:
. as $n
| if $n < 2 then 1
else {sfact: 1, fact: 1}
| reduce range (2;1+$n) as $i (.;
.fact *= $i
| .sfact *= .fact)
| .sfact
end;
 
def H:
. as $n
| if $n < 2 then 1
else
reduce range(2;1+$n) as $i ( {hfact: 1};
.hfact *= ($i | power($i)))
| .hfact
end;
 
def af:
. as $n
| if $n < 1 then 0
else {afact: 0, fact: 1, sign: (if $n%2 == 0 then -1 else 1 end)}
| reduce range(1; 1+$n) as $i (.;
.fact *= $i
| .afact += .fact * .sign
| .sign *= -1)
| .afact
end;
def ef: # recursive
. as $n
| if $n < 1 then 1
else $n | power( ($n-1)|ef )
end;
def rf:
. as $n
| {i: 0, fact: 1}
| until( .fact >= $n;
.i += 1
| .fact = .fact * .i)
| if .fact > $n then null else .i end;</syntaxhighlight>
''' The tasks:'''
<syntaxhighlight lang="jq">
"First 10 superfactorials:",
(range(0;10) | sf),
"\nFirst 10 hyperfactorials:",
(range(0; 10) | H),
"\nFirst 10 alternating factorials:",
(range(0;10) | af),
"\n\nFirst 5 exponential factorials:",
(range(0;5) | ef),
 
"\nThe number of digits in 5$ is \(5 | ef | tostring | length)",
 
"\nReverse factorials:",
( 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119 | "\(rf) <- rf(\(.))")
</syntaxhighlight>
{{out}}
Invocation: gojq -nr -f special-factorials.jq
 
The output is essentially as for [[#Wren|Wren]] and so is not repeated here.
 
=={{header|Julia}}==
No recursion.
<langsyntaxhighlight lang="julia">superfactorial(n) = n < 1 ? 1 : mapreduce(factorial, *, 1:n)
sf(n) = superfactorial(n)
 
Line 117 ⟶ 1,073:
H(n) = hyperfactorial(n)
 
alternating_factorial(n) = n < 1 ? -10 : mapreduce(i -> (-1)^(n - i) * factorial(i), +, 1:n)
af(n) = alternating_factorial(n)
 
Line 124 ⟶ 1,080:
 
function reverse_factorial(n)
forn i in== 1:100000 && return 0
fac = factorial(typeofone(n)(i))
for i in 2:10000
fac *= i
fac == n && return i
fac > n && break
Line 133 ⟶ 1,091:
rf(n) = reverse_factorial(n)
 
println("N Superfactorial Hyperfactorial", " "^18, "Alternating Factorial Exponential Factorial\n", "-"^8898)
for n in 0:9
print(n, " ")
for f in [sf, H, af, n＄]
if n < 5 || f != n＄
print(rpad((f(Int128(n)), 25f == H ? 37 : 24))
end
end
Line 150 ⟶ 1,108:
println(rpad(n, 10), rf(n))
end
</langsyntaxhighlight>{{out}}
<pre>
N Superfactorial Hyperfactorial Alternating Factorial Exponential Factorial
--------------------------------------------------------------------------------------------------
0 1 1 -1 0 1
1 1 1 1 1 1
2 2 4 1 1 2
3 12 108 5 5 9
4 288 27648 19 19 262144
5 34560 86400000 101
6 24883200 4031078400000 619
7 125411328000 3319766398771200000 4421
8 5056584744960000 55696437941726556979200000 -907465429310504960 35899
9 1834933472251084800000 21577941222941856209168026828800000 326981
9 8705808953839190016 2649120435010011136 326981
 
The number of digits in n＄(5) is 183231
Line 170 ⟶ 1,128:
N Reverse Factorial
-------------------------
1 10
2 2
6 3
Line 181 ⟶ 1,139:
3628800 10
119 nothing
</pre>
 
=={{header|Kotlin}}==
{{trans|C}}
<syntaxhighlight lang="scala">import java.math.BigInteger
import java.util.function.Function
 
/* n! = 1 * 2 * 3 * ... * n */
fun factorial(n: Int): BigInteger {
val bn = BigInteger.valueOf(n.toLong())
var result = BigInteger.ONE
var i = BigInteger.TWO
while (i <= bn) {
result *= i++
}
return result
}
 
/* if(n!) = n */
fun inverseFactorial(f: BigInteger): Int {
if (f == BigInteger.ONE) {
return 0
}
 
var p = BigInteger.ONE
var i = BigInteger.ONE
 
while (p < f) {
p *= i++
}
 
if (p == f) {
return i.toInt() - 1
}
return -1
}
 
/* sf(n) = 1! * 2! * 3! * ... . n! */
fun superFactorial(n: Int): BigInteger {
var result = BigInteger.ONE
for (i in 1..n) {
result *= factorial(i)
}
return result
}
 
/* H(n) = 1^1 * 2^2 * 3^3 * ... * n^n */
fun hyperFactorial(n: Int): BigInteger {
var result = BigInteger.ONE
for (i in 1..n) {
val bi = BigInteger.valueOf(i.toLong())
result *= bi.pow(i)
}
return result
}
 
/* af(n) = -1^(n-1)*1! + -1^(n-2)*2! + ... + -1^(0)*n! */
fun alternatingFactorial(n: Int): BigInteger {
var result = BigInteger.ZERO
for (i in 1..n) {
if ((n - i) % 2 == 0) {
result += factorial(i)
} else {
result -= factorial(i)
}
}
return result
}
 
/* n$ = n ^ (n - 1) ^ ... ^ (2) ^ 1 */
fun exponentialFactorial(n: Int): BigInteger {
var result = BigInteger.ZERO
for (i in 1..n) {
result = BigInteger.valueOf(i.toLong()).pow(result.toInt())
}
return result
}
 
fun testFactorial(count: Int, f: Function<Int, BigInteger>, name: String) {
println("First $count $name:")
for (i in 0 until count) {
print("${f.apply(i)} ")
}
println()
}
 
fun testInverse(f: Long) {
val n = inverseFactorial(BigInteger.valueOf(f))
if (n < 0) {
println("rf($f) = No Solution")
} else {
println("rf($f) = $n")
}
}
 
fun main() {
testFactorial(10, ::superFactorial, "super factorials")
println()
 
testFactorial(10, ::hyperFactorial, "hyper factorials")
println()
 
testFactorial(10, ::alternatingFactorial, "alternating factorials")
println()
 
testFactorial(5, ::exponentialFactorial, "exponential factorials")
println()
 
testInverse(1)
testInverse(2)
testInverse(6)
testInverse(24)
testInverse(120)
testInverse(720)
testInverse(5040)
testInverse(40320)
testInverse(362880)
testInverse(3628800)
testInverse(119)
}</syntaxhighlight>
{{out}}
<pre>First 10 super factorials:
1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
 
First 10 hyper factorials:
1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
 
First 10 alternating factorials:
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials:
0 1 2 9 262144
 
rf(1) = 0
rf(2) = 2
rf(6) = 3
rf(24) = 4
rf(120) = 5
rf(720) = 6
rf(5040) = 7
rf(40320) = 8
rf(362880) = 9
rf(3628800) = 10
rf(119) = No Solution</pre>
 
=={{header|Lua}}==
{{trans|C}}
<syntaxhighlight lang="lua">-- n! = 1 * 2 * 3 * ... * n-1 * n
function factorial(n)
local result = 1
local i = 1
while i <= n do
result = result * i
i = i + 1
end
return result
end
 
-- if(n!) = n
function inverse_factorial(f)
local p = 1
local i = 1
 
if f == 1 then
return 0
end
 
while p < f do
p = p * i
i = i + 1
end
 
if p == f then
return i - 1
end
return -1
end
 
-- sf(n) = 1! * 2! * 3! * ... * (n-1)! * n!
function super_factorial(n)
local result = 1
local i = 1
while i <= n do
result = result * factorial(i)
i = i + 1
end
return result
end
 
-- H(n) = 1^1 * 2^2 * 3^3 * ... * (n-1)^(n-1) * n^n
function hyper_factorial(n)
local result = 1
for i=1, n do
result = result * i ^ i
end
return result
end
 
-- af(n) = -1^(n-1)*1! + -1^(n-1)*2! + ... + -1^(1)*(n-1)! + -1^(0)*n!
function alternating_factorial(n)
local result = 0
for i=1, n do
if (n - i) % 2 == 0 then
result = result + factorial(i)
else
result = result - factorial(i)
end
end
return result
end
 
-- n$ = n ^ (n-1) ^ ... ^ 2 ^ 1
function exponential_factorial(n)
local result = 0
for i=1, n do
result = i ^ result
end
return result
end
 
function test_factorial(count, f, name)
print("First " .. count .. " " .. name)
for i=1,count do
io.write(math.floor(f(i - 1)) .. " ")
end
print()
print()
end
 
function test_inverse(f)
local n = inverse_factorial(f)
if n < 0 then
print("rf(" .. f .. " = No Solution")
else
print("rf(" .. f .. " = " .. n)
end
end
 
test_factorial(9, super_factorial, "super factorials")
test_factorial(8, hyper_factorial, "hyper factorials")
test_factorial(10, alternating_factorial, "alternating factorials")
test_factorial(5, exponential_factorial, "exponential factorials")
 
test_inverse(1)
test_inverse(2)
test_inverse(6)
test_inverse(24)
test_inverse(120)
test_inverse(720)
test_inverse(5040)
test_inverse(40320)
test_inverse(362880)
test_inverse(3628800)
test_inverse(119)</syntaxhighlight>
{{out}}
<pre>First 9 super factorials
1 1 2 12 288 34560 24883200 125411328000 5056584744960000
 
First 8 hyper factorials
1 1 4 108 27648 86400000 4031078400000 3319766398771200000
 
First 10 alternating factorials
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials
0 1 2 9 262144
 
rf(1 = 0
rf(2 = 2
rf(6 = 3
rf(24 = 4
rf(120 = 5
rf(720 = 6
rf(5040 = 7
rf(40320 = 8
rf(362880 = 9
rf(3628800 = 10
rf(119 = No Solution</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[sf, expf]
sf[n_] := BarnesG[2 + n]
expf[n_] := Power @@ Range[n, 1, -1]
 
sf /@ Range[0, 9]
Hyperfactorial /@ Range[0, 9]
AlternatingFactorial /@ Range[0, 9]
expf /@ Range[0, 4]</syntaxhighlight>
{{out}}
<pre>{1, 1, 2, 12, 288, 34560, 24883200, 125411328000, 5056584744960000, 1834933472251084800000}
{1, 1, 4, 108, 27648, 86400000, 4031078400000, 3319766398771200000, 55696437941726556979200000, 21577941222941856209168026828800000}
{0, 1, 1, 5, 19, 101, 619, 4421, 35899, 326981}
{1, 1, 2, 9, 262144}</pre>
 
=={{header|Nim}}==
{{libheader|bignum}}
<syntaxhighlight lang="nim">import math, strformat, strutils, sugar
import bignum
 
proc pow(a: int; n: Int): Int =
## Compute a^n for "n" big integer.
var n = n
var a = newInt(a)
if a > 0:
result = newInt(1)
# Start with Int values for "n".
while not n.isZero:
if (n and 1) != 0:
result *= a
n = n shr 1
a *= a
 
func sf(n: Natural): Int =
result = newInt(1)
for i in 2..n:
result *= fac(i)
 
func hf(n: Natural): Int =
result = newInt(1)
for i in 2..n:
result *= pow(i, uint(i))
 
func af(n: Natural): Int =
result = newInt(0)
var m = (n and 1) shl 1 - 1
for i in 1..n:
result += m * fac(i)
m = -m
 
func ef(n: Natural): Int =
result = newInt(1)
for k in 2..n:
result = pow(k, result)
 
func rf(n: int | Int): int =
if n == 1: return 0
result = 1
var p = newInt(1)
while p < n:
inc result
p *= result
if p > n: result = -1
 
let sfs = collect(newSeq, for n in 0..9: sf(n))
echo &"First {sfs.len} superfactorials: ", sfs.join(" ")
 
let hfs = collect(newSeq, for n in 0..9: hf(n))
echo &"First {hfs.len} hyperfactorials: ", hfs.join(" ")
 
let afs = collect(newSeq, for n in 0..9: af(n))
echo &"First {afs.len} alternating factorials: ", afs.join(" ")
 
let efs = collect(newSeq, for n in 0..4: ef(n))
echo &"First {efs.len} exponential factorials: ", efs.join(" ")
 
echo "\nNumber of digits of ef(5): ", len($ef(5))
 
echo "\nReverse factorials:"
for n in [1, 2, 6, 24, 119, 120, 720, 5040, 40320, 362880, 3628800]:
let r = rf(n)
echo &"{n:7}: ", if r >= 0: &"{r:2}" else: "undefined"</syntaxhighlight>
 
{{out}}
<pre>First 10 superfactorials: 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
First 10 hyperfactorials: 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
First 10 alternating factorials: 0 1 1 5 19 101 619 4421 35899 326981
First 5 exponential factorials: 1 1 2 9 262144
 
Number of digits of ef(5): 183231
 
Reverse factorials:
1: 0
2: 2
6: 3
24: 4
119: undefined
120: 5
720: 6
5040: 7
40320: 8
362880: 9
3628800: 10</pre>
 
=={{header|Perl}}==
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use strict;
use warnings;
use feature qw<signatures say>;
no warnings qw<experimental::signatures>;
use bigint try => 'GMP';
use ntheory qw<vecprod vecsum vecreduce vecfirstidx>;
 
sub f ($n) { vecreduce { $a * $b } 1, 1..$n }
sub sf ($n) { vecprod map { f($_) } 1..$n }
sub H ($n) { vecprod map { $_ ** $_ } 1..$n }
sub af ($n) { vecsum map { (-1) ** ($n-$_) * f($_) } 1..$n }
sub ef ($n) { vecreduce { $b ** $a } 1..$n }
sub rf ($n) {
my $v = vecfirstidx { f($_) >= $n } 0..1E6;
$n == f($v) ? $v : 'Nope'
}
 
say 'sf : ' . join ' ', map { sf $_ } 0..9;
say 'H : ' . join ' ', map { H $_ } 0..9;
say 'af : ' . join ' ', map { af $_ } 0..9;
say 'ef : ' . join ' ', map { ef $_ } 1..4;
say '5$ has ' . length(5**4**3**2) . ' digits';
say 'rf : ' . join ' ', map { rf $_ } <1 2 6 24 120 720 5040 40320 362880 3628800>;
say 'rf(119) = ' . rf(119);</syntaxhighlight>
{{out}}
<pre>sf : 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
H : 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
af : 0 1 1 5 19 101 619 4421 35899 326981
ef : 1 2 9 262144
5$ has 183231 digits
rf : 0 2 3 4 5 6 7 8 9 10
rf(119) = Nope</pre>
 
=={{header|Phix}}==
{{libheader|Phix/mpfr}}
Rather than leave this as four somewhat disjoint tasks with quite a bit of repetition, I commoned-up init/loop/print into test(),
which means sf/H/af/ef aren't usable independently as-is, but reconstitution should be easy enough
(along with somewhat saner and thread-safe routine-local vars).
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">mpz</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- res, scratch var</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">sf</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_fac_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">H</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">sgn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">af</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_fac_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sgn</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">sgn</span> <span style="color: #0000FF;">*=</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
<span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fn</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">ef</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_get_integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpz_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">fmt</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">fn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">init</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #000000;">9</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: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">m</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">init</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">sgn</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)?</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (af only)</span>
<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;">n</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">fn</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- or papply(tagset(n),fn)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"First 10 superfactorials: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sf</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"First 10 hyperfactorials: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">H</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"First 10 alternating factorials: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">af</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"First 5 exponential factorials: %s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ef</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">ef</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (nb now only works because ef(4) was just called)</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;">"Number of digits in 5$: %,d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">mpz_sizeinbase</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">rf</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #008000;">"0"</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">fac</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</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: #008080;">while</span> <span style="color: #000000;">fac</span><span style="color: #0000FF;"><</span><span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">fac</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">i</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">fac</span><span style="color: #0000FF;">=</span><span style="color: #000000;">n</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #7060A8;">sprint</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>
<span style="color: #000000;">i</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: #008000;">"undefined"</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</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;">"Reverse factorials: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">24</span><span style="color: #0000FF;">,</span><span style="color: #000000;">120</span><span style="color: #0000FF;">,</span><span style="color: #000000;">720</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5040</span><span style="color: #0000FF;">,</span><span style="color: #000000;">40320</span><span style="color: #0000FF;">,</span><span style="color: #000000;">362880</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3628800</span><span style="color: #0000FF;">,</span><span style="color: #000000;">119</span><span style="color: #0000FF;">},</span><span style="color: #000000;">rf</span><span style="color: #0000FF;">))})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
First 10 superfactorials: 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
First 10 hyperfactorials: 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
First 10 alternating factorials: 0 1 1 5 19 101 619 4421 35899 326981
First 5 exponential factorials: 1 1 2 9 262144
Number of digits in 5$: 183,231
Reverse factorials: 0 2 3 4 5 6 7 8 9 10 undefined
</pre>
 
=={{header|PureBasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="purebasic">Procedure.q factorial(n.i)
If n < 2
ProcedureReturn 1
Else
ProcedureReturn n * Factorial(n - 1)
EndIf
EndProcedure
 
Procedure.q sf(n.i)
p.i = 1
For k.i = 1 To n
p = p * factorial(k)
Next k
ProcedureReturn p
EndProcedure
 
Procedure.q H(n.i)
p.i = 1
For k.i = 1 To n
p = p * Pow(k, k)
Next k
ProcedureReturn p
EndProcedure
 
Procedure.q af(n.i)
s.i = 0
For i.i = 1 To n
s = s + Pow((-1), (n-i)) * factorial(i)
Next i
ProcedureReturn s
EndProcedure
 
Procedure.q ef(n.i)
If n < 2
ProcedureReturn 1
Else
ProcedureReturn Pow(n, ef(n-1))
EndIf
EndProcedure
 
Procedure.i rf(n.i)
r.i = 0
While #True
rr.i = factorial(r)
If rr > n : ProcedureReturn -1 : EndIf
If rr = n : ProcedureReturn r : EndIf
r + 1
Wend
EndProcedure
 
OpenConsole()
PrintN("First 8 ...")
PrintN(" superfactorials hyperfactorials alternating factorials")
For n.i = 0 To 7 ;con 8 o más necesitaríamos BigInt
PrintN(RSet(Str(sf(n)),16) + " " + RSet(Str(H(n)),19) + " " + RSet(Str(af(n)),19))
Next n
 
PrintN(#CRLF$ + #CRLF$ + "First 5 exponential factorials:")
For n.i = 0 To 4
Print(Str(ef(n)) + " ")
Next n
 
PrintN(#CRLF$ + #CRLF$ + "Reverse factorials:")
For n.i = 1 To 10
PrintN(RSet(Str(rf(factorial(n))),2) + " <- rf(" + Str(factorial(n)) + ")")
Next n
PrintN(RSet(Str(rf(factorial(119))),2) + " <- rf(119)")
 
PrintN(#CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()</syntaxhighlight>
 
=={{header|Python}}==
Writing a custom factorial instead of math.prod is trivial but using a standard library tool is always a nice change.
 
It also means less code :)
<syntaxhighlight lang="python">
#Aamrun, 5th October 2021
 
from math import prod
 
def superFactorial(n):
return prod([prod(range(1,i+1)) for i in range(1,n+1)])
 
def hyperFactorial(n):
return prod([i**i for i in range(1,n+1)])
 
def alternatingFactorial(n):
return sum([(-1)**(n-i)*prod(range(1,i+1)) for i in range(1,n+1)])
 
def exponentialFactorial(n):
if n in [0,1]:
return 1
else:
return n**exponentialFactorial(n-1)
def inverseFactorial(n):
i = 1
while True:
if n == prod(range(1,i)):
return i-1
elif n < prod(range(1,i)):
return "undefined"
i+=1
 
print("Superfactorials for [0,9] :")
print({"sf(" + str(i) + ") " : superFactorial(i) for i in range(0,10)})
 
print("\nHyperfactorials for [0,9] :")
print({"H(" + str(i) + ") " : hyperFactorial(i) for i in range(0,10)})
 
print("\nAlternating factorials for [0,9] :")
print({"af(" + str(i) + ") " : alternatingFactorial(i) for i in range(0,10)})
 
print("\nExponential factorials for [0,4] :")
print({str(i) + "$ " : exponentialFactorial(i) for i in range(0,5)})
 
print("\nDigits in 5$ : " , len(str(exponentialFactorial(5))))
 
factorialSet = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
 
print("\nInverse factorials for " , factorialSet)
print({"rf(" + str(i) + ") ":inverseFactorial(i) for i in factorialSet})
 
print("\nrf(119) : " + inverseFactorial(119))
</syntaxhighlight>
{{out}}
<pre>
Superfactorials for [0,9] :
{'sf(0) ': 1, 'sf(1) ': 1, 'sf(2) ': 2, 'sf(3) ': 12, 'sf(4) ': 288, 'sf(5) ': 34560, 'sf(6) ': 24883200, 'sf(7) ': 125411328000, 'sf(8) ': 5056584744960000, 'sf(9) ': 1834933472251084800000}
 
Hyperfactorials for [0,9] :
{'H(0) ': 1, 'H(1) ': 1, 'H(2) ': 4, 'H(3) ': 108, 'H(4) ': 27648, 'H(5) ': 86400000, 'H(6) ': 4031078400000, 'H(7) ': 3319766398771200000, 'H(8) ': 55696437941726556979200000, 'H(9) ': 21577941222941856209168026828800000}
 
Alternating factorials for [0,9] :
{'af(0) ': 0, 'af(1) ': 1, 'af(2) ': 1, 'af(3) ': 5, 'af(4) ': 19, 'af(5) ': 101, 'af(6) ': 619, 'af(7) ': 4421, 'af(8) ': 35899, 'af(9) ': 326981}
 
Exponential factorials for [0,4] :
{'0$ ': 1, '1$ ': 1, '2$ ': 2, '3$ ': 9, '4$ ': 262144}
 
Digits in 5$ : 183231
 
Inverse factorials for [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
{'rf(1) ': 0, 'rf(2) ': 2, 'rf(6) ': 3, 'rf(24) ': 4, 'rf(120) ': 5, 'rf(720) ': 6, 'rf(5040) ': 7, 'rf(40320) ': 8, 'rf(362880) ': 9, 'rf(3628800) ': 10}
 
rf(119) : undefined
</pre>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="Quackery">
[ 1 & ] is odd ( n --> b )
 
[ 1 swap
[ 10 / dup 0 > while
dip 1+ again ]
drop ] is digitcount ( n --> n )
 
[ 1 1 rot times
[ i^ 1+ *
tuck * swap ]
drop ] is s! ( n --> n )
 
[ 1 swap times
[ i^ 1+ dup ** * ] ] is h! ( n --> n )
 
[ 0 1 rot times
[ i^ 1+ * tuck
i odd iff - else +
swap ]
drop ] is a! ( n --> n )
 
[ dup 0 = if done
dup 1 - recurse ** ] is **! ( n --> n )
 
[ this ] is undefined ( --> t )
 
[ dup 1 = iff
[ drop 0 ] done
1 swap
[ over /mod 0 != iff
[ drop undefined
swap ]
done
dip 1+
dup 1 = until
dip [ 1 - ] ]
drop ] is i! ( n --> n )
 
 
say "Superfactorials:" sp
10 times [ i^ s! echo sp ]
cr cr
say "Hyperfactorials:" sp
10 times [ i^ h! echo sp ]
cr cr
say "Alternating factorials: "
10 times [ i^ a! echo sp ]
cr cr
say "Exponential factorials: "
5 times [ i^ **! echo sp ]
cr cr
say "Number of digits in $5: "
5 **! digitcount echo
cr cr
say "Inverse factorials: "
' [ 1 2 6 24 119 120 720 5040
40320 362880 3628800 ]
witheach [ i! echo sp ]</syntaxhighlight>
 
{{out}}
 
<pre>Superfactorials: 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
 
Hyperfactorials: 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
 
Alternating factorials: 0 1 1 5 19 101 619 4421 35899 326981
 
Exponential factorials: 0 1 2 9 262144
 
Number of digits in $5: 183231
 
Inverse factorials: 0 2 3 4 undefined 5 6 7 8 9 10
</pre>
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" line>sub postfix:<!> ($n) { [*] 1 .. $n }
sub postfix:<$> ($n) { [R**] 1 .. $n }
 
sub sf ($n) { [*] map { $_! }, 1 .. $n }
sub H ($n) { [*] map { $_ ** $_ }, 1 .. $n }
sub af ($n) { [+] map { (-1) ** ($n - $_) * $_! }, 1 .. $n }
sub rf ($n) {
state @f = 1, |[\*] 1..*;
$n == .value ?? .key !! Nil given @f.first: :p, * >= $n;
}
 
say 'sf : ', map &sf , 0..9;
say 'H : ', map &H , 0..9;
say 'af : ', map &af , 0..9;
say '$ : ', map *$ , 1..4;
 
say '5$ has ', 5$.chars, ' digits';
 
say 'rf : ', map &rf, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800;
say 'rf(119) = ', rf(119).raku;</syntaxhighlight>
{{out}}
<pre>
sf : (1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000)
H : (1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000)
af : (0 1 1 5 19 101 619 4421 35899 326981)
$ : (1 2 9 262144)
5$ has 183231 digits
rf : (0 2 3 4 5 6 7 8 9 10)
rf(119) = Nil</pre>
 
=={{header|REXX}}==
<syntaxhighlight lang="rexx">
/* REXX program to calculate Special factorials */
 
numeric digits 35
 
line = "superfactorials 0-9: "
do n = 0 to 9
line = line superfactorial(n)
end
say line
 
line = "hyperfactorials 0-9: "
do n = 0 to 9
line = line hyperfactorial(n)
end
say line
 
line = "alternating factorials 0-9:"
do n = 0 to 9
line = line alternatingfactorial(n)
end
say line
 
line = "exponential factorials 0-4:"
do n = 0 to 4
line = line exponentialfactorial(n)
end
say line
 
say "exponential factorial 5: ",
length(format(exponentialfactorial(5), , , 0)) "digits"
 
line = "inverse factorials: "
numbers = "1 2 6 24 120 720 5040 40320 362880 3628800 119"
do i = 1 to words(numbers)
line = line inversefactorial(word(numbers,i))
end
say line
 
return
 
 
superfactorial: procedure
parse arg n
sf = 1
f = 1
do k = 1 to n
f = f * k
sf = sf * f
end
return sf
 
hyperfactorial: procedure
parse arg n
hf = 1
do k = 1 to n
hf = hf * k ** k
end
return hf
 
alternatingfactorial: procedure
parse arg n
af = 0
f = 1
do i = 1 to n
f = f * i
af = af + (-1) ** (n - i) * f
end
return af
 
exponentialfactorial: procedure
parse arg n
ef = 1
do i = 1 to n
ef = i ** ef
end
return ef
 
inversefactorial: procedure
parse arg f
n = 1
do i = 2 while n < f
n = n * i
end
if n = f then
if i > 2 then
return i - 1
else
return 0
else
return "undefined"
</syntaxhighlight>
{{out}}
<pre>
superfactorials 0-9: 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
hyperfactorials 0-9: 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
alternating factorials 0-9: 0 1 1 5 19 101 619 4421 35899 326981
exponential factorials 0-4: 1 1 2 9 262144
exponential factorial 5: 183231 digits
inverse factorials: 0 2 3 4 5 6 7 8 9 10 undefined
</pre>
 
=={{header|RPL}}==
Super factorial:
≪ 1 1 ROT '''FOR''' j j FACT * '''NEXT'''
≫ '<span style="color:blue">SFACT</span>' STO
Hyper factorial:
≪ 1 1 ROT '''FOR''' j j DUP ^ * '''NEXT'''
≫ '<span style="color:blue">HFACT</span>' STO
Alternating factorial:
≪ → n
≪ 0 '''IF''' n '''THEN'''
1 n '''FOR''' j -1 n j - ^ j FACT * + '''NEXT'''
≫ ≫ '<span style="color:blue">AFACT</span>' STO
Exponential factorial:
≪ '''IF''' DUP '''THEN'''
DUP 1 - 1 '''FOR''' j j ^ -1 '''STEP'''
'''ELSE''' NOT '''END'''
≫ '<span style="color:blue">EFACT</span>' STO
Inverse factorial - this function actually inverses Gamma(x+1), so its result is always defined:
≪ 'FACT(x)' OVER - 'x' ROT LN ROOT 'x' PURGE
≫ '<span style="color:blue">IFACT</span>' STO
 
≪ { } 0 9 FOR j j <span style="color:blue">SFACT</span> + NEXT ≫ EVAL
≪ { } 0 9 FOR j j <span style="color:blue">HFACT</span> + NEXT ≫ EVAL
≪ { } 0 9 FOR j j <span style="color:blue">AFACT</span> + NEXT ≫ EVAL
≪ { } 0 4 FOR j j <span style="color:blue">EFACT</span> + NEXT ≫ EVAL
3628800 <span style="color:blue">IFACT</span>
119 <span style="color:blue">IFACT</span>
{{out}}
<pre>
6: { 1 1 2 12 288 34560 24883200 125411328000 5.05658474496E+15 1.83493347225E+21 }
5: { 1 1 4 108 27648 86400000 4.0310784E+12 3.31976639877E+18 5.56964379417E+25 2.15779412229E+34 }
4: { 0 1 1 5 19 101 619 4421 35899 326981 }
3: { 0 1 2 9 262144 }
2: 10
1: 4.99509387149
</pre>
 
=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "bigint.s7i";
 
const func bigInteger: superfactorial (in bigInteger: limit) is func
result
var bigInteger: product is 1_;
local
var bigInteger: k is 0_;
begin
for k range 1_ to limit do
product *:= !k; # prefix ! calculates the factorial in Seed7
end for;
end func;
 
const func bigInteger: hyperfactorial (in bigInteger: limit) is func
result
var bigInteger: product is 1_;
local
var bigInteger: k is 0_;
begin
for k range 1_ to limit do
product *:= k ** ord(k);
end for;
end func;
 
const func bigInteger: alternating (in bigInteger: limit) is func
result
var bigInteger: sum is 0_;
local
var bigInteger: i is 0_;
begin
for i range 1_ to limit do
sum +:= (-1_) ** ord(limit - i) * !i;
end for;
end func;
 
const func bigInteger: exponential (in bigInteger: limit) is func
result
var bigInteger: pow is 0_;
local
var bigInteger: n is 0_;
begin
for n range 1_ to limit do
pow := n ** ord(pow);
end for;
end func;
 
const func integer: invFactorial (in integer: n) is func
result
var integer: r is 0;
local
var integer: a is 1;
var integer: b is 1;
begin
if n <> 1 then
while n > a do
incr(b);
a *:= b;
end while;
if a = n then
r := b;
else
r := -1;
end if;
end if;
end func;
 
const proc: show (in bigInteger: limit, inout bigInteger: aVariable,
ref func bigInteger: anExpression) is func
 
begin
for aVariable range 0_ to limit do
write(anExpression <& " ");
end for;
writeln; writeln;
end func;
 
const proc: main is func
local
var bigInteger: x is 0_;
var integer: n is 0;
begin
writeln("First 10 superfactorials:");
show(9_, x, superfactorial(x));
writeln("First 10 hyperfactorials:");
show(9_, x, hyperfactorial(x));
writeln("First 10 alternating factorials:");
show(9_, x, alternating(x));
writeln("First 5 exponential factorials:");
show(4_, x, exponential(x));
for n range [] (1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119) do
writeln("invFactorial(" <& n <& ") = " <& invFactorial(n));
end for;
end func;</syntaxhighlight>
{{out}}
<pre>
First 10 superfactorials:
1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
 
First 10 hyperfactorials:
1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
 
First 10 alternating factorials:
0 1 1 5 19 101 619 4421 35899 326981
 
First 5 exponential factorials:
0 1 2 9 262144
 
invFactorial(1) = 0
invFactorial(2) = 2
invFactorial(6) = 3
invFactorial(24) = 4
invFactorial(120) = 5
invFactorial(720) = 6
invFactorial(5040) = 7
invFactorial(40320) = 8
invFactorial(362880) = 9
invFactorial(3628800) = 10
invFactorial(119) = -1
</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func sf(n) { 1..n -> prod {|k| k! } }
func H(n) { 1..n -> prod {|k| k**k } }
func af(n) { 1..n -> sum {|k| (-1)**(n-k) * k! } }
func ef(n) { 1..n -> reduce({|a,b| b**a }, 1) }
 
func factorial_valuation(n,p) {
(n - n.sumdigits(p)) / (p-1)
}
 
func p_adic_inverse (p, k) {
 
var n = (k * (p - 1))
 
while (factorial_valuation(n, p) < k) {
n -= (n % p)
n += p
}
 
return n
}
 
func rf(f) {
 
return nil if (f < 0)
return 0 if (f <= 1)
 
var t = valuation(f, 2) || return nil
var n = p_adic_inverse(2, t)
var d = factor(n + 1)[-1]
 
if (f.valuation(d) == factorial_valuation(n+1, d)) {
++n
}
 
for p in (primes(2, n)) {
var v = factorial_valuation(n, p)
f.valuation(p) == v || return nil
f /= p**v
}
 
(f == 1) ? n : nil
}
 
say ('sf : ', 10.of(sf).join(' '))
say ('H : ', 10.of(H).join(' '))
say ('af : ', 10.of(af).join(' '))
say ('ef : ', 5.of(ef).join(' '))
 
say "ef(5) has #{ef(5).len} digits"
 
say ('rf : ', [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800].map(rf))
say ('rf(119) = ', rf(119) \\ 'nil')
say ('rf is defined for: ', 8.by { defined(rf(_)) }.join(', ' ) + ', ...')</syntaxhighlight>
{{out}}
<pre>
sf : 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000
H : 1 1 4 108 27648 86400000 4031078400000 3319766398771200000 55696437941726556979200000 21577941222941856209168026828800000
af : 0 1 1 5 19 101 619 4421 35899 326981
ef : 1 1 2 9 262144
ef(5) has 183231 digits
rf : [0, 2, 3, 4, 5, 6, 7, 8, 9, 10]
rf(119) = nil
rf is defined for: 0, 1, 2, 6, 24, 120, 720, 5040, ...
</pre>
 
Line 187 ⟶ 2,222:
{{libheader|Wren-fmt}}
We've little choice but to use BigInt here as Wren can only deal natively with integers up to 2^53.
<langsyntaxhighlight ecmascriptlang="wren">import "./big" for BigInt
import "./fmt" for Fmt
 
var f = Fn.new { |n|
if (n < 2) return BigInt.one
var fact = BigInt.one
for (i in 2..n) fact = fact * i
return fact
}
 
var sf = Fn.new { |n|
if (n < 2) return BigInt.one
var sfact = BigInt.one
forvar (ifact in 2..n) sfact = sfact * fBigInt.call(i)one
for (i in 2..n) {
fact = fact * i
sfact = sfact * fact
}
return sfact
}
Line 214 ⟶ 2,246:
if (n < 1) return BigInt.zero
var afact = BigInt.zero
var fact = BigInt.one
var sign = (n%2 == 0) ? -1 : 1
for (i in 1..n) {
afactfact = afactfact +* f.call(i) * sign
afact = afact + fact * sign
sign = -sign
}
Line 230 ⟶ 2,264:
var rf = Fn.new { |n|
var i = 0
var fact = BigInt.one
while (true) {
var fact = f.call(i)
if (fact == n) return i
if (fact > n) return "none"
i = i + 1
fact = fact * i
}
}
Line 255 ⟶ 2,290:
System.print("Reverse factorials:")
var facts = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119]
for (fact in facts) Fmt.print("$4s <- rf($d)", rf.call(fact), fact)</langsyntaxhighlight>
 
{{out}}
Marvin
55

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/309397...354654"