Special factorials: Difference between revisions

{{trans|Nim}}

V result = BigInt(1)

L(i) 2 .. n

L(n) [1, 2, 6, 24, 119, 120, 720, 5040, 40320, 362880, 3628800]

V r = rf(n)

{{out}}

=={{header|C}}==

#include <stdint.h>

#include <stdio.h>

return 0;

{{out}}

<pre>First 9 super factorials:

=={{header|C++}}==

{{trans|C}}

#include <cstdint>

#include <iostream>

return 0;

{{out}}

<pre>First 9 super factorials

=={{header|Factor}}==

{{works with|Factor|0.99 2021-02-05}}

math.parser math.ranges prettyprint sequences sequences.extras ;

IN: rosetta-code.special-factorials

{ 1 2 6 24 120 720 5040 40320 362880 3628800 119 }

{{out}}

<pre>

=={{header|Fermat}}==

Function H(n) = Prod<k=1, n>[k^k].

!!' ';

for n=1 to 10 do !!Rf(n!) od;

=={{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.

if n<2 then return 1 else return n*factorial(n-1)

end function

print rf(factorial(n));" ";

next n

=={{header|Go}}==

{{trans|Wren}}

import (

fmt.Printf("%4s <- rf(%d)\n", srfact, fact)

}

{{out}}

some of the specific tasks (some of the hyperfactorials and the computation of 5$)

but can otherwise be used.

# for integer precision:

def power($b): . as $a | reduce range(0;$b) as $i (1; . * $a);

.i += 1

| .fact = .fact * .i)

''' The tasks:'''

"First 10 superfactorials:",

(range(0;10) | sf),

"\nReverse factorials:",

( 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119 | "\(rf) <- rf(\(.))")

{{out}}

Invocation: gojq -nr -f special-factorials.jq

=={{header|Julia}}==

No recursion.

sf(n) = superfactorial(n)

println(rpad(n, 10), rf(n))

end

<pre>

N Superfactorial Hyperfactorial Alternating Factorial Exponential Factorial

=={{header|Kotlin}}==

{{trans|C}}

import java.util.function.Function

testInverse(3628800)

testInverse(119)

{{out}}

<pre>First 10 super factorials:

=={{header|Lua}}==

{{trans|C}}

function factorial(n)

local result = 1

test_inverse(362880)

test_inverse(3628800)

{{out}}

<pre>First 9 super factorials

=={{header|Mathematica}}/{{header|Wolfram Language}}==

sf[n_] := BarnesG[2 + n]

expf[n_] := Power @@ Range[n, 1, -1]

Hyperfactorial /@ Range[0, 9]

AlternatingFactorial /@ Range[0, 9]

{{out}}

<pre>{1, 1, 2, 12, 288, 34560, 24883200, 125411328000, 5056584744960000, 1834933472251084800000}

=={{header|Nim}}==

{{libheader|bignum}}

import bignum

for n in [1, 2, 6, 24, 119, 120, 720, 5040, 40320, 362880, 3628800]:

let r = rf(n)

{{out}}

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use feature qw<signatures say>;

say '5$ has ' . length(5**4**3**2) . ' digits';

say 'rf : ' . join ' ', map { rf $_ } <1 2 6 24 120 720 5040 40320 362880 3628800>;

{{out}}

<pre>sf : 1 1 2 12 288 34560 24883200 125411328000 5056584744960000 1834933472251084800000

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).

<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: #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>

{{out}}

<pre>

It also means less code :)

#Aamrun, 5th October 2021

print("\nrf(119) : " + inverseFactorial(119))

{{out}}

<pre>

</pre>

=={{header|Raku}}==

sub postfix:<$> ($n) { [R**] 1 .. $n }

say 'rf : ', map &rf, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800;

{{out}}

<pre>

=={{header|REXX}}==

/*───────────────────────────────────── alternating factorials, exponential factorials.*/

numeric digits 1000 /*allows humongous results to be shown.*/

rfr: if x==f then return #; ?= 'undefined'; return ?

hdr: parse arg ?,,$; say 'the first ten '?"factorials:"; return

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

=={{header|Seed7}}==

include "bigint.s7i";

writeln("invFactorial(" <& n <& ") = " <& invFactorial(n));

end for;

{{out}}

<pre>

=={{header|Sidef}}==

func H(n) { 1..n -> prod {|k| k**k } }

func af(n) { 1..n -> sum {|k| (-1)**(n-k) * k! } }

say ('rf : ', [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800].map(rf))

say ('rf(119) = ', rf(119) \\ 'nil')

{{out}}

<pre>

{{libheader|Wren-fmt}}

We've little choice but to use BigInt here as Wren can only deal natively with integers up to 2^53.

import "/fmt" for Fmt

System.print("Reverse factorials:")

var facts = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 119]

{{out}}