Rosetta Code

Multifactorial: Difference between revisions

Page Discussion

Multifactorial (view source)

Revision as of 14:12, 4 January 2024

60,292 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
(Added F# version)
m (→‎{{header|Wren}}: Minor tidy)
 
(165 intermediate revisions by 85 users not shown)
Line 1:
{{task}}
The factorial of a number, written as <math>n!</math> is defined as <math>n! = n(n-1)(n-2)...(2)(1)</math>
 
The factorial of a number, written as <math>n!</math>, is defined as <math>n! = n(n-1)(n-2)...(2)(1)</math>.
A generalization of this is the [http://mathworld.wolfram.com/Multifactorial.html multifactorials] where:
 
[http://mathworld.wolfram.com/Multifactorial.html Multifactorials] generalize factorials as follows:
: <math>n! = n(n-1)(n-2)...(2)(1)</math>
: <math>n!! = n(n-2)(n-4)...</math>
Line 8 ⟶ 9:
: <math>n!! !! = n(n-4)(n-8)...</math>
: <math>n!! !! ! = n(n-5)(n-10)...</math>
: Where the products are for positive integers.
 
In all cases, the terms in the products are positive integers.
If we define the degree of the multifactorial as the difference in successive terms that are multiplied together for a multifactorial (The number of exclamation marks) then the task is to
 
If we define the degree of the multifactorial as the difference in successive terms that are multiplied together for a multifactorial (the number of exclamation marks), then the task is twofold:
# Write a function that given n and the degree, calculates the multifactorial.
# Use the function to generate and display here a table of the first 1..10ten members (1 to 10) of the first five degrees of multifactorial.
 
 
<small>'''Note:''' The [[wp:Factorial#Multifactorials|wikipedia entry on multifactorials]] gives a different formula. This task uses the [http://mathworld.wolfram.com/Multifactorial.html Wolfram mathworld definition].</small>
'''Note:''' The [[wp:Factorial#Multifactorials|wikipedia entry on multifactorials]] gives a different formula. This task uses the [http://mathworld.wolfram.com/Multifactorial.html Wolfram mathworld definition].
 
=={{header|11l}}==
{{trans|Crystal}}
 
<syntaxhighlight lang="11l">F multifact(n, d)
R product((n .< 1).step(-d))
 
L(d) 1..5
print(‘Degree ’d‘: ’(1..10).map(n -> multifact(n, @d)))</syntaxhighlight>
 
{{out}}
<pre>
Degree 1: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
Degree 2: [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
Degree 3: [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
Degree 4: [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
Degree 5: [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]
</pre>
 
{{trans|Wren}}
<syntaxhighlight lang="11l">F multifact(=n, d)
V prod = 1
L n > 1
prod *= n
n -= d
R prod</syntaxhighlight>
 
=={{header|360 Assembly}}==
For maximum compatibility, this program uses only the basic instruction set (S/360 1964 POP).
<syntaxhighlight lang="360asm">* Multifactorial 09/05/2016
MULFACR CSECT
USING MULFACR,13
SAVEAR B STM-SAVEAR(15)
DC 17F'0'
STM STM 14,12,12(13) prolog
ST 13,4(15) "
ST 15,8(13) "
LR 13,15 "
LA I,1 i=1
LOOPI C I,D do i=1 to deg
BH ELOOPI leave i
LA L,W+4 l=@p
LA J,1 j=1
LOOPJ C J,N do j=1 to num
BH ELOOPJ leave j
LA R,1 r=1
LCR S,I s=-i
LR K,J k=j
LOOPK C K,=F'2' do k=j to 2 by s
BL ELOOPK leave k
MR RR,K r=r*k
AR K,S k=k+s
B LOOPK next k
ELOOPK CVD R,Y pack r
MVC X,=XL12'402020202020202020202120' ed mask
ED X,Y+2 edit r
MVC 0(8,L),X+4 output r
LA L,8(L) l=l+8
LA J,1(J) j=j+1
B LOOPJ next j
ELOOPJ WTO MF=(E,W)
LA I,1(I) i=i+1
B LOOPI next i
ELOOPI L 13,4(0,13) epilog
LM 14,12,12(13) "
XR 15,15 "
BR 14 "
N DC F'10' number
D DC F'5' degree
W DC 0F,H'84',H'0',CL80' ' length,zero,text
X DS CL12 temp
Y DS D packed PL8
I EQU 6
J EQU 7
K EQU 8
S EQU 9
RR EQU 10 even reg of R for MR opcode
R EQU 11
L EQU 12
END MULFACR</syntaxhighlight>
{{out}}
<pre>
1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
 
PROC Multifactorial(INT n,d REAL POINTER res)
REAL r
 
IntToReal(1,res)
WHILE n>1
DO
IntToReal(n,r)
RealMult(res,r,res)
n==-d
OD
RETURN
 
PROC Main()
BYTE n,d
REAL r
 
Put(125) PutE() ;clear the screen
FOR d=1 TO 5
DO
PrintF("Degree %B:",d)
FOR n=1 TO 10
DO
Multifactorial(n,d,r)
Put(32) PrintR(r)
OD
PutE()
OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multifactorial.png Screenshot from Atari 8-bit computer]
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO; use Ada.Text_IO;
procedure Mfact is
 
Line 35 ⟶ 168:
New_line;
end loop;
end Mfact;</langsyntaxhighlight>
{{out}}
<pre>
Line 44 ⟶ 177:
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Aime}}==
<syntaxhighlight lang="aime">mf(integer a, n)
{
integer o;
 
o = 1;
do {
o *= a;
} while (0 < (a -= n));
 
o;
}
 
main(void)
{
integer i, j;
 
i = 0;
while ((i += 1) <= 5) {
o_("degree ", i, ":");
j = 0;
while ((j += 1) <= 10) {
o_("\t", mf(j, i));
}
o_("\n");
}
 
0;
}</syntaxhighlight>
{{out}}
<pre>degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
degree 2: 1 2 3 8 15 48 105 384 945 3840
degree 3: 1 2 3 4 10 18 28 80 162 280
degree 4: 1 2 3 4 5 12 21 32 45 120
degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|ALGOL 68}}==
Translation of C.
<syntaxhighlight lang="algol68">BEGIN
INT highest degree = 5;
INT largest number = 10;
CO Recursive implementation of multifactorial function CO
PROC multi fact = (INT n, deg) INT :
(n <= deg | n | n * multi fact(n - deg, deg));
CO Iterative implementation of multifactorial function CO
PROC multi fact i = (INT n, deg) INT :
BEGIN
INT result := n, nn := n;
WHILE (nn >= deg + 1) DO
result TIMESAB nn - deg;
nn MINUSAB deg
OD;
result
END;
CO Print out multifactorials CO
FOR i TO highest degree DO
printf (($l, "Degree ", g(0), ":"$, i));
FOR j TO largest number DO
printf (($xg(0)$, multi fact (j, i)))
OD
OD
END
</syntaxhighlight>
{{out}}
<pre>
 
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|ALGOL W}}==
Iterative multifactorial based on Ada, AutoHotkey, etc.
<syntaxhighlight lang="algolw">begin
% returns the multifactorial of n with the specified degree %
integer procedure multifactorial ( integer value n, degree ) ;
begin
integer mf, v;
mf := v := n;
while begin
v := v - degree;
v > 1
end do mf := mf * v;
mf
end multifactorial ;
 
% tests as per task %
for degree := 1 until 5 do begin
i_w := 1; s_w := 0; % output formatting %
write( "Degree: ", degree, ":" );
for v := 1 until 10 do begin
writeon( " ", multifactorial( v, degree ) )
end for_v
end for_degree
end.</syntaxhighlight>
{{out}}
<pre>
Degree: 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree: 2: 1 2 3 8 15 48 105 384 945 3840
Degree: 3: 1 2 3 4 10 18 28 80 162 280
Degree: 4: 1 2 3 4 5 12 21 32 45 120
Degree: 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|AppleScript}}==
<syntaxhighlight lang="applescript">on multifactorial(n, d)
set f to 1
repeat with n from n to 2 by -d
set f to f * n
end repeat
return f
end multifactorial
 
on task()
set table to ""
repeat with degree from 1 to 5
set row to linefeed & "Degree " & degree & ":"
repeat with n from 1 to 10
set row to row & (space & multifactorial(n, degree))
end repeat
set table to table & row
end repeat
return table
end task
 
task()</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">"
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50"</syntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">multifact: function [n deg][
if? n =< deg -> n
else -> n * multifact n-deg deg
]
loop 1..5 'i [
prints ["Degree" i ":"]
loop 1..10 'j [
prints [multifact j i " "]
]
print ""
]</syntaxhighlight>
 
{{out}}
 
<pre>Degree 1 : 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2 : 1 2 3 8 15 48 105 384 945 3840
Degree 3 : 1 2 3 4 10 18 28 80 162 280
Degree 4 : 1 2 3 4 5 12 21 32 45 120
Degree 5 : 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Loop, 5 {
Output .= "Degree " (i := A_Index) ": "
Loop, 10
Output .= MultiFact(A_Index, i) (A_Index = 10 ? "`n" : ", ")
}
MsgBox, % Output
 
MultiFact(n, d) {
Result := n
while 1 < n -= d
Result *= n
return, Result
}</syntaxhighlight>
'''Output:'''
<pre>Degree 1: 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800
Degree 2: 1, 2, 3, 8, 15, 48, 105, 384, 945, 3840
Degree 3: 1, 2, 3, 4, 10, 18, 28, 80, 162, 280
Degree 4: 1, 2, 3, 4, 5, 12, 21, 32, 45, 120
Degree 5: 1, 2, 3, 4, 5, 6, 14, 24, 36, 50</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f MULTIFACTORIAL.AWK
# converted from Go
BEGIN {
for (k=1; k<=5; k++) {
printf("degree %d:",k)
for (n=1; n<=10; n++) {
printf(" %d",multi_factorial(n,k))
}
printf("\n")
}
exit(0)
}
function multi_factorial(n,k, r) {
r = 1
for (; n>1; n-=k) {
r *= n
}
return(r)
}
</syntaxhighlight>
{{out}}
<pre>
degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
degree 2: 1 2 3 8 15 48 105 384 945 3840
degree 3: 1 2 3 4 10 18 28 80 162 280
degree 4: 1 2 3 4 5 12 21 32 45 120
degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{trans|FreeBASIC}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">100 FUNCTION multiFactorial (n, degree)
110 IF n < 2 THEN
120 LET multiFactorial = 1
130 EXIT FUNCTION
140 END IF
150 LET result = n
160 FOR i = n - degree TO 2 STEP -degree
170 LET result = result * i
180 NEXT i
190 LET multiFactorial = result
200 END FUNCTION
210
220 FOR degree = 1 TO 5
230 PRINT "Degree"; degree; " => ";
240 FOR n = 1 TO 10
250 PRINT multiFactorial(n, degree); " ";
260 NEXT n
270 PRINT
280 NEXT degree
290 END</syntaxhighlight>
{{out}}
<pre>
Degree 1 => 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2 => 1 2 3 8 15 48 105 384 945 3840
Degree 3 => 1 2 3 4 10 18 28 80 162 280
Degree 4 => 1 2 3 4 5 12 21 32 45 120
Degree 5 => 1 2 3 4 5 6 14 24 36 50
</pre>
 
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic">REM >multifact
FOR i% = 1 TO 5
PRINT "Degree "; i%; ":";
FOR j% = 1 TO 10
PRINT " ";FNmultifact(j%, i%);
NEXT
PRINT
NEXT
END
:
DEF FNmultifact(n%, degree%)
LOCAL i%, mfact%
mfact% = 1
FOR i% = n% TO 1 STEP -degree%
mfact% = mfact% * i%
NEXT
= mfact%</syntaxhighlight>
{{out}}
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 PROGRAM "MultiFac.bas"
110 FOR I=1 TO 5
120 PRINT "Degree";I;": ";
130 FOR J=1 TO 10
140 PRINT MFACT(J,I);" ";
150 NEXT
160 PRINT
170 NEXT
180 DEF MFACT(N,DEGREE)
190 LET RESULT=1
200 FOR X=N TO 1 STEP-DEGREE
210 LET RESULT=RESULT*X
220 NEXT
230 LET MFACT=RESULT
240 END DEF</syntaxhighlight>
 
=={{header|BQN}}==
<syntaxhighlight lang="bqn">MultiFact ← ×´⊣-↕∘⌈∘÷×⊢
 
MultiFact⌜⟜(5⊸↑) 1+↕10</syntaxhighlight>
{{out}}
<pre>┌─
╵ 1 1 1 1 1
2 2 2 2 2
6 3 3 3 3
24 8 4 4 4
120 15 10 5 5
720 48 18 12 6
5040 105 28 21 14
40320 384 80 32 24
362880 945 162 45 36
3628800 3840 280 120 50
┘</pre>
 
=={{header|C}}==
{{uses from|Library|C Runtime|component1=printf}}
<syntaxhighlight lang="c">
<lang c>
/* Include statements and constant definitions */
#include <stdio.h>
Line 78 ⟶ 515:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 87 ⟶ 524:
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|C sharp}}==
<syntaxhighlight lang="csharp">namespace RosettaCode.Multifactorial
{
using System;
using System.Linq;
 
internal static class Program
{
private static void Main()
{
Console.WriteLine(string.Join(Environment.NewLine,
Enumerable.Range(1, 5)
.Select(
degree =>
string.Join(" ",
Enumerable.Range(1, 10)
.Select(
number =>
Multifactorial(number, degree))))));
}
 
private static int Multifactorial(int number, int degree)
{
if (degree < 1)
{
throw new ArgumentOutOfRangeException("degree");
}
 
var count = 1 + (number - 1) / degree;
if (count < 1)
{
throw new ArgumentOutOfRangeException("number");
}
 
return Enumerable.Range(0, count)
.Aggregate(1, (accumulator, index) => accumulator * (number - degree * index));
}
}
}</syntaxhighlight>
Output:
<pre>1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">
#include <algorithm>
#include <iostream>
#include <iterator>
/*Generate multifactorials to 9
 
Line 96 ⟶ 582:
*/
int main(void) {
for (int g = 1; g < 10; g++) {
int v[1211], n=0;
generate_n(std::ostream_iterator<int>(std::cout, " "), 10, [&]{n++; return v[n]=(g<n)? v[n-g]*n : n;});
for (int n = 1; n < 11; n++) {
v[n] = (gstd::cout << n)? v[n-g]*n std: n:endl;
}
std::cout << v[n] << " ";
return }0;
std::cout << std::endl;
}
return 0;
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 119 ⟶ 602:
1 2 3 4 5 6 7 8 9 10
</pre>
 
=={{header|Clojure}}==
 
<syntaxhighlight lang="clojure">(defn !! [m n]
(->> (iterate #(- % m) n) (take-while pos?) (apply *)))
 
(doseq [m (range 1 6)]
(prn m (map #(!! m %) (range 1 11))))</syntaxhighlight>
 
{{out}}
 
<pre>1 (1 2 6 24 120 720 5040 40320 362880 3628800)
2 (1 2 3 8 15 48 105 384 945 3840)
3 (1 2 3 4 10 18 28 80 162 280)
4 (1 2 3 4 5 12 21 32 45 120)
5 (1 2 3 4 5 6 14 24 36 50)</pre>
 
=={{header|CLU}}==
<syntaxhighlight lang="clu">multifactorial = proc (n, degree: int) returns (int)
result: int := 1
for i: int in int$from_to_by(n, 1, -degree) do
result := result * i
end
return (result)
end multifactorial
 
start_up = proc ()
po: stream := stream$primary_output()
for n: int in int$from_to(1, 10) do
for d: int in int$from_to(1, 5) do
stream$putright(po, int$unparse(multifactorial(n,d)), 10)
end
stream$putc(po, '\n')
end
end start_up</syntaxhighlight>
{{out}}
<pre> 1 1 1 1 1
2 2 2 2 2
6 3 3 3 3
24 8 4 4 4
120 15 10 5 5
720 48 18 12 6
5040 105 28 21 14
40320 384 80 32 24
362880 945 162 45 36
3628800 3840 280 120 50</pre>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">
(defun mfac (n m)
(reduce #'* (loop for i from n downto 1 by m collect i)))
Line 129 ⟶ 658:
i (loop for j from 1 to 10
collect (mfac j i))))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 141 ⟶ 670:
8: 1 2 3 4 5 6 7 8 9 20
9: 1 2 3 4 5 6 7 8 9 10
10: 1 2 3 4 5 6 7 8 9 10</pre>
 
</pre>
=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub multifac(n: uint32, d: uint32): (r: uint32) is
r := 1;
loop
r := r * n;
if n <= d then break; end if;
n := n - d;
end loop;
end sub;
 
var d: uint32 := 1;
while d <= 5 loop
print_i32(d);
print(": ");
var n: uint32 := 1;
while n <= 10 loop
print_i32(multifac(n, d));
print(" ");
n := n + 1;
end loop;
print_nl();
d := d + 1;
end loop;</syntaxhighlight>
{{out}}
<pre>1: 1 2 6 24 120 720 5040 40320 362880 3628800
2: 1 2 3 8 15 48 105 384 945 3840
3: 1 2 3 4 10 18 28 80 162 280
4: 1 2 3 4 5 12 21 32 45 120
5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Crystal}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">def multifact(n, d)
n.step(to: 1, by: -d).product
end
 
(1..5).each {|d| puts "Degree #{d}: #{(1..10).map{|n| multifact(n, d)}.join "\t"}"}</syntaxhighlight>
'''output'''
<pre style="overflow:scroll">
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.range;
 
T multifactorial(T=long)(in int n, in int m) pure /*purenothrow*/ {
T one = 1;
return reduce!q{a * b}(one, iota(n, 0, -m));
Line 153 ⟶ 728:
 
void main() {
foreach (immutable m; 1 .. 11)
writefln("%2d: %s", m, iota(1, 11)
.map!(n => multifactorial(n, m))());
}</langsyntaxhighlight>
{{out}}
<pre> 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Line 168 ⟶ 743:
9: 1 2 3 4 5 6 7 8 9 10
10: 1 2 3 4 5 6 7 8 9 10 </pre>
 
=={{header|Dart}}==
<syntaxhighlight lang="dart">
main()
{
int n=5,d=3;
int z= fact(n,d);
print('$n factorial of degree $d is $z');
for(var j=1;j<=5;j++)
{
print('first 10 numbers of degree $j :');
for(var i=1;i<=10;i++)
{
int z=fact(i,j);
print('$z');
}
print('\n');
}
}
 
int fact(int a,int b)
{
if(a<=b||a==0)
return a;
if(a>1)
return a*fact((a-b),b);
}
</syntaxhighlight>
 
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc nonrec multifac(int n, deg) ulong:
ulong result;
result := 1;
while n > 1 do
result := result * n;
n := n - deg
od;
result
corp
 
proc nonrec main() void:
byte n, d;
for n from 1 upto 10 do
for d from 1 upto 5 do
write(multifac(n,d):10)
od;
writeln()
od
corp</syntaxhighlight>
{{out}}
<pre> 1 1 1 1 1
2 2 2 2 2
6 3 3 3 3
24 8 4 4 4
120 15 10 5 5
720 48 18 12 6
5040 105 28 21 14
40320 384 80 32 24
362880 945 162 45 36
3628800 3840 280 120 50</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
function MultiFact(Num,Deg: integer): integer;
{Multifactorial from Degree and Number}
var N: integer;
begin
N:=Num;
Result:=Num;
if N = 0 then Result:=1
else while true do
begin
N := N - deg;
if N<1 then break;
Result:=Result * N;
end;
end;
 
 
procedure ShowMultifactorial(Memo: TMemo);
{Show combinations of deg/num of multifactorial}
var Deg,Num: integer;
var S: string;
begin
S:='';
for Deg:=1 to 5 do
begin
S:=S+Format('Degree: %d:',[Deg]);
for Num:=1 to 10 do S:=S+' '+Format('%7d',[MultiFact(Num,Deg)]);
S:=S+#$0D#$0A;
end;
Memo.Lines.Add(S);
end;
 
</syntaxhighlight>
{{out}}
<pre>
Degree: 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree: 2: 1 2 3 8 15 48 105 384 945 3840
Degree: 3: 1 2 3 4 10 18 28 80 162 280
Degree: 4: 1 2 3 4 5 12 21 32 45 120
Degree: 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
 
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight lang=easylang>
func mfact n k .
r = 1
while n > 1
r *= n
n -= k
.
return r
.
for k = 1 to 5
write "degree " & k & ":"
for n = 1 to 10
write " " & mfact n k
.
print ""
.
</syntaxhighlight>
 
=={{header|Elixir}}==
{{trans|Erlang}}
<syntaxhighlight lang="elixir">defmodule RC do
def multifactorial(n,d) do
Enum.take_every(n..1, d) |> Enum.reduce(1, fn x,p -> x*p end)
end
end
 
Enum.each(1..5, fn d ->
multifac = for n <- 1..10, do: RC.multifactorial(n,d)
IO.puts "Degree #{d}: #{inspect multifac}"
end)</syntaxhighlight>
 
{{out}}
<pre>
Degree 1: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
Degree 2: [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
Degree 3: [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
Degree 4: [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
Degree 5: [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]
</pre>
 
=={{header|Erlang}}==
<langsyntaxhighlight lang="erlang">-module(multifac).
-compile(export_all).
 
Line 181 ⟶ 907:
lists:foreach(fun (D) ->
io:format("Degree ~b: ~p~n",[D, [ multifac(N,D) || N <- Ns]])
end, Ds).</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="erlang">5> multifac:main().
Degree 1: [1,2,6,24,120,720,5040,40320,362880,3628800]
Degree 2: [1,2,3,8,15,48,105,384,945,3840]
Line 189 ⟶ 915:
Degree 4: [1,2,3,4,5,12,21,32,45,120]
Degree 5: [1,2,3,4,5,6,14,24,36,50]
ok</langsyntaxhighlight>
 
=={{header|ERRE}}==
<syntaxhighlight lang="erre">
PROGRAM MULTIFACTORIAL
 
PROCEDURE MULTI_FACT(NUM,DEG->MF)
RESULT=NUM
N=NUM
IF N=0 THEN
MF=1
EXIT PROCEDURE
END IF
LOOP
N-=DEG
EXIT IF N<=0
RESULT*=N
END LOOP
MF=RESULT
END PROCEDURE
 
BEGIN
PRINT(CHR$(12);)
FOR DEG=1 TO 10 DO
PRINT("Degree";DEG;":";)
FOR NUM=1 TO 10 DO
MULTI_FACT(NUM,DEG->MF)
PRINT(MF;)
END FOR
PRINT
END FOR
END PROGRAM
</syntaxhighlight>
<pre>
Degree 1 : 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2 : 1 2 3 8 15 48 105 384 945 3840
Degree 3 : 1 2 3 4 10 18 28 80 162 280
Degree 4 : 1 2 3 4 5 12 21 32 45 120
Degree 5 : 1 2 3 4 5 6 14 24 36 50
Degree 6 : 1 2 3 4 5 6 7 16 27 40
Degree 7 : 1 2 3 4 5 6 7 8 18 30
Degree 8 : 1 2 3 4 5 6 7 8 9 20
Degree 9 : 1 2 3 4 5 6 7 8 9 10
Degree 10 : 1 2 3 4 5 6 7 8 9 10
</pre>
 
=={{header|F_Sharp|F#}}==
 
<langsyntaxhighlight lang="fsharp">let rec mfact d = function
| n when n <= d -> n
| n -> n * mfact d (n-d)
Line 208 ⟶ 978:
ignore (List.init maxDegree (fun i -> showFor (i+1)))
0
</syntaxhighlight>
</lang>
<pre>1: [1; 2; 6; 24; 120; 720; 5040; 40320; 362880; 3628800]
2: [1; 2; 3; 8; 15; 48; 105; 384; 945; 3840]
Line 214 ⟶ 984:
4: [1; 2; 3; 4; 5; 12; 21; 32; 45; 120]
5: [1; 2; 3; 4; 5; 6; 14; 24; 36; 50]</pre>
 
=={{header|Factor}}==
<syntaxhighlight lang="text">USING: formatting io kernel math math.ranges prettyprint
sequences ;
IN: rosetta-code.multifactorial
 
: multifactorial ( n degree -- m )
neg 1 swap <range> product ;
 
: mf-row ( degree -- )
dup "Degree %d: " printf
10 [1,b] [ swap multifactorial pprint bl ] with each ;
: main ( -- )
5 [1,b] [ mf-row nl ] each ;
MAIN: main</syntaxhighlight>
{{out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Forth}}==
<syntaxhighlight lang="text">: !n negate swap 1 dup rot do i * over +loop nip ;
: test cr 6 1 ?do 11 1 ?do i j !n . loop cr loop ;</syntaxhighlight>
{{out}}
<pre>test
1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50
ok</pre>
 
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<syntaxhighlight lang="fortran">program test
implicit none
integer :: i, j, n
 
do i = 1, 5
write(*, "(a, i0, a)", advance = "no") "Degree ", i, ": "
do j = 1, 10
n = multifactorial(j, i)
write(*, "(i0, 1x)", advance = "no") n
end do
write(*,*)
end do
contains
 
function multifactorial (range, degree)
integer :: multifactorial, range, degree
integer :: k
multifactorial = product((/(k, k=range, 1, -degree)/))
 
end function multifactorial
end program test</syntaxhighlight>
{{out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64
 
Function multiFactorial (n As UInteger, degree As Integer) As UInteger
If n < 2 Then Return 1
Var result = n
For i As Integer = n - degree To 2 Step -degree
result *= i
Next
Return result
End Function
 
For degree As Integer = 1 To 5
Print "Degree"; degree; " => ";
For n As Integer = 1 To 10
Print multiFactorial(n, degree); " ";
Next n
Print
Next degree
 
Print
Print "Press any key to quit"
Sleep</syntaxhighlight>
 
{{out}}
<pre>
Degree 1 => 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2 => 1 2 3 8 15 48 105 384 945 3840
Degree 3 => 1 2 3 4 10 18 28 80 162 280
Degree 4 => 1 2 3 4 5 12 21 32 45 120
Degree 5 => 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|FunL}}==
<syntaxhighlight lang="funl">def multifactorial( n, d ) = product( n..1 by -d )
 
for d <- 1..5
println( d, [multifactorial(i, d) | i <- 1..10] ))</syntaxhighlight>
 
{{out}}
 
<pre>
1, [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
2, [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
3, [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
4, [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
5, [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]
</pre>
 
=={{header|GAP}}==
<syntaxhighlight lang="gap">MultiFactorial := function(n, k)
local r;
r := 1;
while n > 1 do
r := r*n;
n := n - k;
od;
return r;
end;
 
PrintArray(List([1 .. 10], n -> List([1 .. 5], k -> MultiFactorial(n, k))));
[ [ 1, 1, 1, 1, 1 ],
[ 2, 2, 2, 2, 2 ],
[ 6, 3, 3, 3, 3 ],
[ 24, 8, 4, 4, 4 ],
[ 120, 15, 10, 5, 5 ],
[ 720, 48, 18, 12, 6 ],
[ 5040, 105, 28, 21, 14 ],
[ 40320, 384, 80, 32, 24 ],
[ 362880, 945, 162, 45, 36 ],
[ 3628800, 3840, 280, 120, 50 ] ]</syntaxhighlight>
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 236 ⟶ 1,149:
fmt.Println()
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 247 ⟶ 1,160:
 
=={{header|Haskell}}==
<syntaxhighlight lang ="haskell">mulfac k:: =(Num 1:sa, whereEnum sa) => [1a .. k] ++ zipWith (*) s-> [k+1..a]
mulfac k = 1 : s
where
s = [1 .. k] <> zipWith (*) s [k + 1 ..]
 
-- forFor single n:
mulfac1 k n = product [n, n-k .. 1]
 
mulfac1 :: (Num a, Enum a) => a -> a -> a
main = mapM_ (print . take 10 . tail . mulfac) [1..5]</lang>
mulfac1 k n = product [n, n - k .. 1]
 
main :: IO ()
main =
mapM_
(print . take 10 . tail . mulfac)
[1 .. 5]
</syntaxhighlight>
{{out}}
<pre>[1,2,6,24,120,720,5040,40320,362880,3628800]
<pre>
[1,2,6,24,120,720,5040,40320,362880,3628800]
[1,2,3,8,15,48,105,384,945,3840]
[1,2,3,4,10,18,28,80,162,280]
[1,2,3,4,5,12,21,32,45,120]
[1,2,3,4,5,6,14,24,36,50]</pre>
 
==Icon and {{header|Unicon}}==
 
The following is Unicon specific but can be readily translated into Icon:
<syntaxhighlight lang="unicon">procedure main(A)
l := integer(A[1]) | 10
every writeRow(n := !l, [: mf(!10,n) :])
end
 
procedure writeRow(n, r)
writes(right(n,3),": ")
every writes(right(!r,8)|"\n")
end
 
procedure mf(n, m)
if n <= 0 then return 1
return n*mf(n-m, m)
end</syntaxhighlight>
 
Sample run:
<pre>
->mf 5
1: 1 2 6 24 120 720 5040 40320 362880 3628800
2: 1 2 3 8 15 48 105 384 945 3840
3: 1 2 3 4 10 18 28 80 162 280
4: 1 2 3 4 5 12 21 32 45 120
5: 1 2 3 4 5 6 14 24 36 50
->
</pre>
 
=={{header|JIS-BASIC}}==
<syntaxhighlight lang="is-basic">100 PROGRAM "Multifac.bas"
<lang J>
110 FOR I=1 TO 5
NB. tacit implementation of the recursive c function
120 PRINT "Degree";I;":";
NB. int multifact(int n,int deg){return n<=deg?n:n*multifact(n-deg,deg);}
130 FOR N=1 TO 10
140 PRINT MFACT(N,I);
150 NEXT
160 PRINT
170 NEXT
180 DEF MFACT(N,D)
190 NUMERIC I,RES
200 IF N<2 THEN LET MFACT=1:EXIT DEF
210 LET RES=N
220 FOR I=N-D TO 2 STEP-D
230 LET RES=RES*I
240 NEXT
250 LET MFACT=RES
260 END DEF</syntaxhighlight>
 
=={{header|J}}==
multifact=: [`([ * - $: ])@.(<~)
<syntaxhighlight lang="j"> NB. n multifact degree
(a:,<' degree'),multifact table >:i.10
multifact=: */@([ - ] * i.@>.@%)&>
('';' degree'),multifact table >:i.10
┌─────────┬──────────────────────────────────────┐
│ │ degree │
Line 285 ⟶ 1,250:
│ 9 │ 362880 945 162 45 36 27 18 9 9 9│
│10 │3628800 3840 280 120 50 40 30 20 10 10│
└─────────┴──────────────────────────────────────┘</syntaxhighlight>
 
</lang>
=={{header|Java}}==
<syntaxhighlight lang="java">public class MultiFact {
private static long multiFact(long n, int deg){
long ans = 1;
for(long i = n; i > 0; i -= deg){
ans *= i;
}
return ans;
}
public static void main(String[] args){
for(int deg = 1; deg <= 5; deg++){
System.out.print("degree " + deg + ":");
for(long n = 1; n <= 10; n++){
System.out.print(" " + multiFact(n, deg));
}
System.out.println();
}
}
}</syntaxhighlight>
{{out}}
<pre>degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
degree 2: 1 2 3 8 15 48 105 384 945 3840
degree 3: 1 2 3 4 10 18 28 80 162 280
degree 4: 1 2 3 4 5 12 21 32 45 120
degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|JavaScript}}==
 
===Iterative===
 
{{trans|C}}
<syntaxhighlight lang="javascript">
<lang JavaScript>
function multifact(n, deg){
var result = n;
Line 302 ⟶ 1,292:
return result;
}
</syntaxhighlight>
</lang>
 
<syntaxhighlight lang="javascript">
{{test}}
<lang JavaScript>
function test (n, deg) {
for (var i = 1; i <= deg; i ++) {
Line 315 ⟶ 1,304:
}
}
</syntaxhighlight>
</lang>
 
{{out}}
<syntaxhighlight lang="javascript">
<lang JavaScript>
test(10, 5)
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Line 325 ⟶ 1,314:
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</syntaxhighlight>
</lang>
 
===Recursive===
 
{{trans|C}}
<syntaxhighlight lang="javascript">function multifact(n, deg){
<lang JavaScript>
function return n <= deg ? n : n * multifact(n - deg, deg){;
}</syntaxhighlight>
return n <= deg ? n : n * multifact(n - deg, deg);
}
</lang>
 
Test
{{test}}
<syntaxhighlight lang="javascript">function test (n, deg) {
<lang JavaScript>
function test for (n,var i = 1; i <= deg; i ++) {
for (var i = 1; i <= deg; ivar ++)results {= '';
for (var j = 1; j <= n; j ++) {
var results = '';
results += multifact(j, i) + ' ';
for (var j = 1; j <= n; j ++) {
}
results += multifact(j, i) + ' ';
console.log('Degree ' + i + ': ' + results);
}
}
console.log('Degree ' + i + ': ' + results);
}</syntaxhighlight>
}
{{Out}}
}
<syntaxhighlight lang="javascript">
</lang>
 
{{out}}
<lang JavaScript>
test(10, 5)
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Line 356 ⟶ 1,340:
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50 </syntaxhighlight>
 
</lang>
=={{header|jq}}==
{{works with|jq|1.4}}
<syntaxhighlight lang="jq"># Input: n
# Output: n * (n - d) * (n - 2d) ...
def multifactorial(d):
. as $n
| ($n / d | floor) as $k
| reduce ($n - (d * range(0; $k))) as $i (1; . * $i);</syntaxhighlight>
 
<syntaxhighlight lang="jq"># Print out a d-by-n table of multifactorials neatly:
def table(d; n):
def lpad(i): tostring | (i - length) * " " + .;
def pp(stream): reduce stream as $i (""; . + ($i | lpad(8)));
range(1; d+1) as $d | "Degree \($d): \( pp(range(1; n+1) | multifactorial($d)) )";</syntaxhighlight>
The specific task:
<syntaxhighlight lang="jq">table(5; 10)</syntaxhighlight>
{{out}}
<syntaxhighlight lang="sh">$ jq -n -r -f Multifactorial.jq
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 1 3 4 5 18 28 40 162 280
Degree 4: 1 1 1 4 5 6 7 32 45 60
Degree 5: 1 1 1 1 5 6 7 8 9 50</syntaxhighlight>
 
=={{header|Julia}}==
<syntaxhighlight lang="julia">using Printf
 
function multifact(n::Integer, k::Integer)
n > 0 && k > 0 || throw(DomainError())
k > 1 || factorial(n)
return prod(n:-k:2)
end
 
const khi = 5
const nhi = 10
println("Showing multifactorial for n in [1, $nhi] and k in [1, $khi].")
for k = 1:khi
a = multifact.(1:nhi, k)
lab = "n" * "!" ^ k
@printf(" %-6s → %s\n", lab, a)
end</syntaxhighlight>
 
{{out}}
<pre>Showing multifactorial for n in [1, 10] and k in [1, 5].
n! → [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
n!! → [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
n!!! → [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
n!!!! → [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
n!!!!! → [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]</pre>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">fun multifactorial(n: Long, d: Int) : Long {
val r = n % d
return (1..n).filter { it % d == r } .reduce { i, p -> i * p }
}
 
fun main(args: Array<String>) {
val m = 5
val r = 1..10L
for (d in 1..m) {
print("%${m}s:".format( "!".repeat(d)))
r.forEach { print(" " + multifactorial(it, d)) }
println()
}
}</syntaxhighlight>
{{Out}}
<pre> !: 1 2 6 24 120 720 5040 40320 362880 3628800
!!: 1 2 3 8 15 48 105 384 945 3840
!!!: 1 2 3 4 10 18 28 80 162 280
!!!!: 1 2 3 4 5 12 21 32 45 120
!!!!!: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def multifact
{lambda {:n :deg}
{if {<= :n :deg}
then :n
else {* :n {multifact {- :n :deg} :deg}}}}}
-> multifact
 
{S.map {lambda {:deg} {br} Degree :deg:
{S.map {{lambda {:deg :n} {multifact :n :deg}} :deg}
{S.serie 1 10}}}
{S.serie 1 5}}
->
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</syntaxhighlight>
 
=={{header|Latitude}}==
 
<syntaxhighlight lang="latitude">use 'format importAllSigils.
 
multiFactorial := {
Range make ($1, 0, - $2) product.
}.
 
1 upto 6 visit {
takes '[degree].
answers := 1 upto 11 to (Array) map { multiFactorial ($1, degree). }.
$stdout printf: ~fmt "Degree ~S: ~S", degree, answers.
}.</syntaxhighlight>
 
{{Out}}
<pre>Degree 1: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
Degree 2: [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
Degree 3: [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
Degree 4: [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
Degree 5: [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]</pre>
 
=={{header|Lua}}==
<syntaxhighlight lang="lua">function multiFact (n, degree)
local fact = 1
for i = n, 2, -degree do
fact = fact * i
end
return fact
end
 
print("Degree\t|\tMultifactorials 1 to 10")
print(string.rep("-", 52))
for d = 1, 5 do
io.write(" " .. d, "\t| ")
for n = 1, 10 do
io.write(multiFact(n, d) .. " ")
end
print()
end</syntaxhighlight>
{{out}}
<pre>Degree | Multifactorials 1 to 10
----------------------------------------------------
1 | 1 2 6 24 120 720 5040 40320 362880 3628800
2 | 1 2 3 8 15 48 105 384 945 3840
3 | 1 2 3 4 10 18 28 80 162 280
4 | 1 2 3 4 5 12 21 32 45 120
5 | 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|MAD}}==
 
<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER
INTERNAL FUNCTION(N,DEG)
ENTRY TO MLTFAC.
RSLT = 1
THROUGH MULT, FOR MPC=N, -DEG, MPC.L.1
MULT RSLT = RSLT * MPC
FUNCTION RETURN RSLT
END OF FUNCTION
THROUGH SHOW, FOR I=1, 1, I.G.10
SHOW PRINT FORMAT OUTP, MLTFAC.(I,1), MLTFAC.(I,2),
0 MLTFAC.(I,3), MLTFAC.(I,4), MLTFAC.(I,5)
VECTOR VALUES OUTP = $5(I10,S1)*$
END OF PROGRAM</syntaxhighlight>
 
{{out}}
 
<pre> 1 1 1 1 1
2 2 2 2 2
6 3 3 3 3
24 8 4 4 4
120 15 10 5 5
720 48 18 12 6
5040 105 28 21 14
40320 384 80 32 24
362880 945 162 45 36
3628800 3840 280 120 50</pre>
 
=={{header|Maple}}==
<syntaxhighlight lang="maple">f := proc (n, m)
local fac, i;
fac := 1;
for i from n by -m to 1 do
fac := fac*i;
end do;
return fac;
end proc:
 
a:=Matrix(5,10):
for i from 1 to 5 do
for j from 1 to 10 do
a[i,j]:=f(j,i);
end do;
end do;
a;</syntaxhighlight>
{{out}}
[1 , 2 , 6 , 24 , 120 , 720 , 5040 , 40320 , 362880 , 3628800]
[ ]
[1 , 2 , 3 , 8 , 15 , 48 , 105 , 384 , 945 , 3840]
[ ]
[1 , 2 , 3 , 4 , 10 , 18 , 28 , 80 , 162 , 280]
[ ]
[1 , 2 , 3 , 4 , 5 , 12 , 21 , 32 , 45 , 120]
[ ]
[1 , 2 , 3 , 4 , 5 , 6 , 14 , 24 , 36 , 50]
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight perl6lang="mathematica">Multifactorial[n_, m_d_] := AbsProduct[x, Apply[ Times{x, Range[-n, -1, m]]-d}]
Table[ Multifactorial[j, i], {i, 5}, {j, 10}] // TableForm</langsyntaxhighlight>
{{out}}
<pre>1: 1 2 6 24 120 720 5040 40320 362880 3628800
Line 368 ⟶ 1,554:
4: 1 2 3 4 5 12 21 32 45 120
5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Maxima}}==
Using built-in function genfact
<syntaxhighlight lang="maxima">
multifactorial(x,n):=genfact(x,x/n,n)$
 
/* Test case */
makelist(multifactorial(i,1),i,1,10);
makelist(multifactorial(i,2),i,1,10);
block(makelist(mod(i,3),i,1,10),at(%%,0=1),%%*makelist(multifactorial(i,3),i,1,10));
block(makelist(mod(i,4),i,1,10),at(%%,0=1),%%*makelist(multifactorial(i,4),i,1,10));
block(makelist(mod(i,5),i,1,10),at(%%,0=1),%%*makelist(multifactorial(i,5),i,1,10));
</syntaxhighlight>
{{out}}
<pre>
[1,2,6,24,120,720,5040,40320,362880,3628800]
[1,2,3,8,15,48,105,384,945,3840]
[1,2,3,4,10,18,28,80,162,280]
[1,2,3,4,5,12,21,32,45,120]
[1,2,3,4,5,6,14,24,36,50]
</pre>
 
=={{header|min}}==
{{works with|min|0.19.3}}
<syntaxhighlight lang="min">(:d (dup 0 <=) (pop 1) (dup d -) (*) linrec) :multifactorial
(:d 1 (dup d multifactorial print! " " print! succ) 10 times newline pop) :row
 
1 (dup "Degree " print! print ": " print! row succ) 5 times</syntaxhighlight>
{{out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [ Stdout (show deg ++ ": " ++ show (map (multifac deg) [1..10]) ++ "\n")
| deg <- [1..5]]
 
multifac :: num->num->num
multifac deg = product . takewhile (>1) . iterate sub
where sub n = n - deg</syntaxhighlight>
{{out}}
<pre>1: [1,2,6,24,120,720,5040,40320,362880,3628800]
2: [1,2,3,8,15,48,105,384,945,3840]
3: [1,2,3,4,10,18,28,80,162,280]
4: [1,2,3,4,5,12,21,32,45,120]
5: [1,2,3,4,5,6,14,24,36,50]</pre>
 
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">П1 <-> П0 П2 ИП0 ИП1 1 + - x>=0
23 ИП2 ИП0 ИП1 - * П2 ИП0 ИП1 -
П1 БП 04 ИП2 С/П</langsyntaxhighlight>
 
Instruction: ''number'' ^ ''degree'' В/О С/П
 
=={{header|Nim}}==
<syntaxhighlight lang="nim"># Recursive
proc multifact(n, deg: int): int =
result = (if n <= deg: n else: n * multifact(n - deg, deg))
# Iterative
proc multifactI(n, deg: int): int =
result = n
var n = n
while n >= deg + 1:
result *= n - deg
n -= deg
for i in 1..5:
stdout.write "Degree ", i, ": "
for j in 1..10:
stdout.write multifactI(j, i), " "
stdout.write('\n')</syntaxhighlight>
 
{{out}}
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Objeck}}==
{{trans|C}}
<langsyntaxhighlight lang="objeck">
class Multifact {
function : MultiFact(n : Int, deg : Int) ~ Int {
Line 400 ⟶ 1,663:
}
}
</syntaxhighlight>
</lang>
 
Output:
Line 409 ⟶ 1,672:
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let multi_fac d n =
let rec loop a x = if x < 2 then a else loop (a * x) (x - d) in
loop n (n - d)
 
let () =
for i = 1 to 5 do
Seq.(ints 1 |> take 10 |> map (multi_fac i) |> map string_of_int)
|> List.of_seq |> String.concat " " |> print_endline
done</syntaxhighlight>
{{out}}
<pre>
1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Oforth}}==
 
<syntaxhighlight lang="oforth">: multifact(n, deg) 1 while( n 0 > ) [ n * n deg - ->n ] ;
: printMulti
| i |
5 loop: i [ System.Out i << " : " << 10 seq map(#[ i multifact]) << cr ] ;</syntaxhighlight>
 
{{out}}
<pre>
1 : [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
2 : [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
3 : [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
4 : [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
5 : [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]
</pre>
 
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (multifactorial n d)
(fold * 1 (iota (div n d) n (negate d))))
 
(for-each (lambda (i)
(display "Degree ")
(display i)
(display ":")
(for-each (lambda (n)
(display " ")
(display (multifactorial n i)))
(iota 10 1))
(print))
(iota 5 1))
</syntaxhighlight>
{{out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 1 3 4 5 18 28 40 162 280
Degree 4: 1 1 1 4 5 6 7 32 45 60
Degree 5: 1 1 1 1 5 6 7 8 9 50
</pre>
 
By the way, we can create few multifactorial functions and use them directly or as part of infix math notation (inside "//" macro).
<syntaxhighlight lang="scheme">
(define (!!!!! n) (multifactorial n 5))
(print (!!!!! 74))
 
(import (math infix-notation))
; register !!!!! as a postfix function
(define \\postfix-functions (put \\postfix-functions '!!!!! #t))
 
; now use "\\" as usual
(print (\\
2 + 74!!!!!
))
</syntaxhighlight>
{{out}}
<pre>
4959435223298761261056
4959435223298761261058
</pre>
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">fac(n,d)=prod(k=0,(n-1)\d,n-k*d)
for(k=1,5,for(n=1,10,print1(fac(n,k)" "));print)</langsyntaxhighlight>
<pre>1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
Line 421 ⟶ 1,765:
 
=={{header|Perl}}==
<syntaxhighlight lang="perl">{ # <-- scoping the cache and bigint clause
A subroutine to generate multifactorials:
my @cache;
<lang perl>use 5.10.0;
use bigint;
 
sub ngmfact {
my ($s, $n) = @_;
state %g;
return 1 if $n <= 0;
my ($n, $d, $key) = ( @_[0], @_[1], $n.'ng'.$d);
if (! $g{cache[$key}) {$gs][$keyn] //= ($n <=* mfact($d+1)?s, $n :- ng($n-$d,$ds)*$n};
}
return $g[$key];
}
 
</lang>
for my $s (1 .. 10) {
Test the subroutine:
print "step=$s: ";
<lang perl>
print join(" ", map(mfact($s, $_), 1 .. 10)), "\n";
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,1), ng(2,1), ng(3,1), ng(4,1), ng(5,1), ng(6,1), ng(7,1), ng(8,1), ng(9,1), ng(10,1) ;
}</syntaxhighlight>
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,2), ng(2,2), ng(3,2), ng(4,2), ng(5,2), ng(6,2), ng(7,2), ng(8,2), ng(9,2), ng(10,2) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,3), ng(2,3), ng(3,3), ng(4,3), ng(5,3), ng(6,3), ng(7,3), ng(8,3), ng(9,3), ng(10,3) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,4), ng(2,4), ng(3,4), ng(4,4), ng(5,4), ng(6,4), ng(7,4), ng(8,4), ng(9,4), ng(10,4) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,5), ng(2,5), ng(3,5), ng(4,5), ng(5,5), ng(6,5), ng(7,5), ng(8,5), ng(9,5), ng(10,5) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,6), ng(2,6), ng(3,6), ng(4,6), ng(5,6), ng(6,6), ng(7,6), ng(8,6), ng(9,6), ng(10,6) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,7), ng(2,7), ng(3,7), ng(4,7), ng(5,7), ng(6,7), ng(7,7), ng(8,7), ng(9,7), ng(10,7) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,8), ng(2,8), ng(3,8), ng(4,8), ng(5,8), ng(6,8), ng(7,8), ng(8,8), ng(9,8), ng(10,8) ;
printf "%s %s %s %s %s %s %s %s %s %s\n", ng(1,9), ng(2,9), ng(3,9), ng(4,9), ng(5,9), ng(6,9), ng(7,9), ng(8,9), ng(9,9), ng(10,9) ;
</lang>
{{out}}
<pre>
step=1: 1 2 6 24 120 720 5040 40320 362880 3628800
step=2: 1 2 3 8 15 48 105 384 945 3840
step=3: 1 2 3 4 10 18 28 80 162 280
step=4: 1 2 3 4 5 12 21 32 45 120
step=5: 1 2 3 4 5 6 14 24 36 50
step=6: 1 2 3 4 5 6 7 16 27 40
step=7: 1 2 3 4 5 6 7 8 18 30
step=8: 1 2 3 4 5 6 7 8 9 20
step=9: 1 2 3 4 5 6 7 8 9 10
step=10: 1 2 3 4 5 6 7 8 9 10
</pre>
 
We can also do this iteratively. ntheory's vecprod makes bigint products if needed, so we don't have to worry about it.
=={{header|Perl 6}}==
{{libheader|ntheory}}
<lang perl6>sub mfact($n, :$degree = 1) { [*] $n, *-$degree ...^ * <= 0 }
<syntaxhighlight lang="perl">use ntheory qw/vecprod/;
 
sub mfac {
my($n,$d) = @_;
vecprod(map { $n - $_*$d } 0 .. int(($n-1)/$d));
}
 
for my $degree (1 .. 5 -> $degree) {
say "$degree: ",join(" ",map &mfact.assuming{mfac(:$_,$degree),} 1 .. 10);
}</langsyntaxhighlight>
{{out}}
<pre>1: 1 2 6 24 120 720 5040 40320 362880 3628800
Line 468 ⟶ 1,811:
4: 1 2 3 4 5 12 21 32 45 120
5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Phix}}==
<!--<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;">multifactorial</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: #000000;">order</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">></span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">multifactorial</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">order</span><span style="color: #0000FF;">,</span><span style="color: #000000;">order</span><span style="color: #0000FF;">)</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: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</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;">5</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">multifactorial</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: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{1,2,6,24,120,720,5040,40320,362880,3628800}
{1,2,3,8,15,48,105,384,945,3840}
{1,2,3,4,10,18,28,80,162,280}
{1,2,3,4,5,12,21,32,45,120}
{1,2,3,4,5,6,14,24,36,50}
</pre>
 
=={{header|Picat}}==
===Using prod/1===
<syntaxhighlight lang="picat">multifactorial(N,Degree) = prod([ I : I in N..-Degree..1]).</syntaxhighlight>
 
===Using reduce/2===
<syntaxhighlight lang="picat">multifactorial2(N,Degree) = reduce(*, [I : I in N..-Degree..1]).</syntaxhighlight>
 
===While loop===
<syntaxhighlight lang="picat">multifactorial3(N,Degree) = M =>
M = 1, I = N,
while(I > 0)
M := M*I,
I := I - Degree
end.</syntaxhighlight>
 
===Recursive variants===
<syntaxhighlight lang="picat">multifactorial4(N,_D) = 1, N <= 0 => true.</syntaxhighlight>
<syntaxhighlight lang="picat">multifactorial4(N,D) = N*multifactorial4(N-D,D).</syntaxhighlight>
<syntaxhighlight lang="picat">multifactorial5(N,D) = M =>
N <= 0 -> M = 1 ; M = N*multifactorial4(N-D,D).</syntaxhighlight>
<syntaxhighlight lang="picat">multifactorial6(N,D) = cond(N <= 0, 1, N*multifactorial6(N-D,D)).</syntaxhighlight>
 
===Test===
<syntaxhighlight lang="picat">import util.
 
go =>
foreach(D in 1..15)
println(D=[multifactorial(I,D) : I in 1..15])
end,
nl.</syntaxhighlight>
 
{{out}}
<pre>1 = [1,2,6,24,120,720,5040,40320,362880,3628800,39916800,479001600,6227020800,87178291200,1307674368000]
2 = [1,2,3,8,15,48,105,384,945,3840,10395,46080,135135,645120,2027025]
3 = [1,2,3,4,10,18,28,80,162,280,880,1944,3640,12320,29160]
4 = [1,2,3,4,5,12,21,32,45,120,231,384,585,1680,3465]
5 = [1,2,3,4,5,6,14,24,36,50,66,168,312,504,750]
6 = [1,2,3,4,5,6,7,16,27,40,55,72,91,224,405]
7 = [1,2,3,4,5,6,7,8,18,30,44,60,78,98,120]
8 = [1,2,3,4,5,6,7,8,9,20,33,48,65,84,105]
9 = [1,2,3,4,5,6,7,8,9,10,22,36,52,70,90]
10 = [1,2,3,4,5,6,7,8,9,10,11,24,39,56,75]
11 = [1,2,3,4,5,6,7,8,9,10,11,12,26,42,60]
12 = [1,2,3,4,5,6,7,8,9,10,11,12,13,28,45]
13 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,30]
14 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
15 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]</pre>
 
===Constraint modelling===
Using constraint modelling for a reversible variant (i.e. all parameters can be inputs or outputs); here shown by identifying all the valid N and the degree given the multifactorial (M).
<syntaxhighlight lang="picat">import cp.
 
%
% Reversible: find Degree and N given M
%
go2 =>
Ms = [4,20,105], % The multifactorials to identify
 
foreach(M in Ms)
println(m=M),
Degree :: 1..10, % limit of the degree
N :: 1..100, % limit of N
All = findall([N,Degree,M], (multifactorial_reversible(N,Degree,M),
solve([M,N,Degree]))),
foreach([NN,DD,MM] in All.sort)
printf("n=%d degree=%d m=%d\n",NN,DD,MM)
end,
nl
end,
nl.
 
% reversible variant (using CP)
multifactorial_reversible(N,_D,M) :-
N #<= 0, M #= 1.
multifactorial_reversible(N,D,M) :-
D #> 0,
N #> 0,
ND #= N-D,
multifactorial_reversible(ND,D,M1),
M #= N*M1.</syntaxhighlight>
 
{{out}}
<pre>Reversible: find Degree and N given M:
m = 4
n=4 degree=3 m=4
n=4 degree=4 m=4
n=4 degree=5 m=4
n=4 degree=6 m=4
n=4 degree=7 m=4
n=4 degree=8 m=4
n=4 degree=9 m=4
n=4 degree=10 m=4
 
m = 20
n=10 degree=8 m=20
 
m = 105
n=7 degree=2 m=105
n=15 degree=8 m=105</pre>
 
=={{header|PicoLisp}}==
{{trans|C}}
<syntaxhighlight lang="picolisp">(de multifact (N Deg)
(let Res N
(while (> N Deg)
(setq Res (* Res (dec 'N Deg))) )
Res ) )
 
(for I 5
(prin "Degree " I ":")
(for J 10
(prin " " (multifact J I)) )
(prinl) )</syntaxhighlight>
Output:
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|PL/I}}==
<syntaxhighlight lang="text">
multi: procedure options (main); /* 29 October 2013 */
declare (i, j, n) fixed binary;
declare text character (6) static initial ('n!!!!!');
 
do i = 1 to 5;
put skip edit (substr(text, 1, i+1), '=' ) (A, COLUMN(8));
do n = 1 to 10;
put edit ( trim( multifactorial(n,i) ) ) (X(1), A);
end;
end;
 
multifactorial: procedure (n, j) returns (fixed(15));
declare (n, j) fixed binary;
declare f fixed (15), m fixed(15);
 
f, m = n;
do while (m > j); f = f * (m-fixed(j)); m = m - j; end;
return (f);
end multifactorial;
 
end multi;
</syntaxhighlight>
Output:
<pre>
n! = 1 2 6 24 120 720 5040 40320 362880 3628800
n!! = 1 2 3 8 15 48 105 384 945 3840
n!!! = 1 2 3 4 10 18 28 80 162 280
n!!!! = 1 2 3 4 5 12 21 32 45 120
n!!!!! = 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|plainTeX}}==
Works with an etex engine.
 
<syntaxhighlight lang="tex">\long\def\antefi#1#2\fi{#2\fi#1}
\def\fornum#1=#2to#3(#4){%
\edef#1{\number\numexpr#2}\edef\fornumtemp{\noexpand\fornumi\expandafter\noexpand\csname fornum\string#1\endcsname
{\number\numexpr#3}{\ifnum\numexpr#4<0 <\else>\fi}{\number\numexpr#4}\noexpand#1}\fornumtemp
}
\long\def\fornumi#1#2#3#4#5#6{\def#1{\unless\ifnum#5#3#2\relax\antefi{#6\edef#5{\number\numexpr#5+(#4)\relax}#1}\fi}#1}
\newcount\result
\def\multifact#1#2{%
\result=1
\fornum\multifactiter=#1 to 1(-#2){\multiply\result\multifactiter}%
\number\result
}
\fornum\degree=1 to 5(+1){Degree \degree: \fornum\ii=1 to 10(+1){\multifact\ii\degree\space\space}\par}
\bye</syntaxhighlight>
 
Output pdf looks like:
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Python}}==
===Python: Iterative===
<langsyntaxhighlight lang="python">>>> from functools import reduce
>>> from operator import mul
>>> def mfac(n, m): return reduce(mul, range(n, 0, -m))
Line 487 ⟶ 2,036:
9: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
10: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> </langsyntaxhighlight>
 
===Python: Recursive===
<langsyntaxhighlight lang="python">>>> def mfac2(n, m): return n if n <= (m + 1) else n * mfac2(n - m, m)
 
>>> for m in range(1, 6): print("%2i: %r" % (m, [mfac2(n, m) for n in range(1, 11)]))
Line 499 ⟶ 2,048:
4: [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
5: [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]
>>> </langsyntaxhighlight>
 
=={{header|Quackery}}==
 
<syntaxhighlight lang="quackery"> [ 1 rot times
[ i 1+ *
dip [ over step ] ]
nip ] is m! ( n --> n! )
 
5 times
[ i^ 1+ 10 times
[ i^ 1+ over m!
echo sp ]
drop cr ]</syntaxhighlight>
 
{{Out}}
 
<pre>1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|R}}==
===Recursive solution===
<syntaxhighlight lang="rsplus">#x is Input
#n is Factorial Number
multifactorial=function(x,n){
if(x<=n+1){
return(x)
}else{
return(x*multifactorial(x-n,n))
}
}</syntaxhighlight>
===Sequence solution===
This task doesn't use big enough numbers to need efficient code, so R can solve this very succinctly.
<syntaxhighlight lang="rsplus">mFact <- function(n, deg) prod(seq(from = n, to = 1, by = -deg))
cat("Simple version:\n")
print(outer(1:10, 1:5, Vectorize(mFact)))</syntaxhighlight>
If we really insist on a pretty table, then we can add some names and transpose the output.
<syntaxhighlight lang="rsplus">mFact <- function(n, deg) prod(seq(from = n, to = 1, by = -deg))
cat("Pretty version:\n")
print(t(outer(setNames(1:10, 1:10), setNames(1:5, paste0("Degree ", 1:5, ":")), Vectorize(mFact))))</syntaxhighlight>
{{out}}
<pre>Simple version:
[,1] [,2] [,3] [,4] [,5]
[1,] 1 1 1 1 1
[2,] 2 2 2 2 2
[3,] 6 3 3 3 3
[4,] 24 8 4 4 4
[5,] 120 15 10 5 5
[6,] 720 48 18 12 6
[7,] 5040 105 28 21 14
[8,] 40320 384 80 32 24
[9,] 362880 945 162 45 36
[10,] 3628800 3840 280 120 50
Pretty version:
1 2 3 4 5 6 7 8 9 10
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
 
(define (multi-factorial-fn m)
(lambda (n)
(let inner ((acc 1) (n n))
(if (<= n m) (* acc n)
(inner (* acc n) (- n m))))))
 
;; using (multi-factorial-fn m) as a first-class function
(for*/list ([m (in-range 1 (add1 5))] [mf-m (in-value (multi-factorial-fn m))])
(for/list ([n (in-range 1 (add1 10))])
(mf-m n)))
 
(define (multi-factorial m n) ((multi-factorial-fn m) n))
 
(for/list ([m (in-range 1 (add1 5))])
(for/list ([n (in-range 1 (add1 10))])
(multi-factorial m n)))</syntaxhighlight>
Output:
<pre>'((1 2 6 24 120 720 5040 40320 362880 3628800)
(1 2 3 8 15 48 105 384 945 3840)
(1 2 3 4 10 18 28 80 162 280)
(1 2 3 4 5 12 21 32 45 120)
(1 2 3 4 5 6 14 24 36 50))
'((1 2 6 24 120 720 5040 40320 362880 3628800)
(1 2 3 8 15 48 105 384 945 3840)
(1 2 3 4 10 18 28 80 162 280)
(1 2 3 4 5 12 21 32 45 120)
(1 2 3 4 5 6 14 24 36 50))</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>for 1 .. 5 -> $degree {
sub mfact($n) { [*] $n, *-$degree ...^ * <= 0 };
say "$degree: ", map &mfact, 1..10
}</syntaxhighlight>
{{out}}
<pre>1: 1 2 6 24 120 720 5040 40320 362880 3628800
2: 1 2 3 8 15 48 105 384 945 3840
3: 1 2 3 4 10 18 28 80 162 280
4: 1 2 3 4 5 12 21 32 45 120
5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|REXX}}==
This version also handles zero as well as positive integers.
<langsyntaxhighlight lang="rexx">/*REXX pgmprogram calculates and displays K-fact (multifactorial) of non-negative integers.*/
numeric digits 1000 /*lets get ka-razy with precisionthe decimal digits. */
parse arg num deg . /*allowget useroptional toarguments specifyfrom numthe &C.L. deg*/
if num=='' | num=='",'" then num=1215 /*Not specified? Then use the default.*/
if deg=='' | deg=='",'" then deg=10 /* " " " " " " */
say '═══showing multiple factorials (1 ──►' deg") for numbers 1 ──►" num
say
do d=1 for deg /*the factorializing (degree) of !'s.*/
_= /*the list of factorials (so far). */
do f=1 for num /* ◄── perform a ! from 1 ───► number.*/
_=_ Kfact(f, d) /*build a list of factorial products.*/
end /*f*/ /* [↑] D can default to unity. */
 
say right('n'copies("!", d), 1+deg) right('['d"]", 2+length(num) )':' _
do d=1 to deg /*the degree of factorialization.*/
_= end /*the list of factorials so far. d*/
exit /*stick a fork in it, we're all done. */
do f=1 to num
/*──────────────────────────────────────────────────────────────────────────────────────*/
_=_ Kfact(f,d) /*construct a list of factorials.*/
Kfact: procedure; !=1; do j=arg(1) to 2 by -word(arg(2) 1,1); !=!*j; end; return !</syntaxhighlight>
end /*f*/ /*(above) D can be omitted. */
'''output''' &nbsp; when using the default input:
<pre>
═══showing multiple factorials (1 ──► 10) for numbers 1 ──► 15
 
n! [1]: 1 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600 6227020800 87178291200 1307674368000
say 'degree' right(d,length(num))':' _ /*show factorials.*/
n!! [2]: 1 2 3 8 15 48 105 384 945 3840 10395 46080 135135 645120 2027025
end /*d*/
exit n!!! [3]: 1 2 3 4 10 18 28 80 162 280 880 1944 3640 12320 /*stick a fork in it, we're done.*/29160
n!!!! [4]: 1 2 3 4 5 12 21 32 45 120 231 384 585 1680 3465
/*──────────────────────────────────KFACT subroutine────────────────────*/
n!!!!! [5]: 1 2 3 4 5 6 14 24 36 50 66 168 312 504 750
Kfact: procedure; !=1; do j=arg(1) to 2 by -word(arg(2) 1, 1)
n!!!!!! [6]: 1 2 3 4 5 6 7 16 27 40 55 72 91 224 !=!*j405
n!!!!!!! [7]: 1 2 3 4 5 6 7 8 18 30 44 60 78 98 end /*j*/120
n!!!!!!!! [8]: 1 2 3 4 5 6 7 8 9 20 33 48 65 84 105
return !</lang>
n!!!!!!!!! [9]: 1 2 3 4 5 6 7 8 9 10 22 36 52 70 90
'''output''' when using the default input:
n!!!!!!!!!! [10]: 1 2 3 4 5 6 7 8 9 10 11 24 39 56 75
<pre style="overflow:scroll">
</pre>
degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800 39916800 479001600
 
degree 2: 1 2 3 8 15 48 105 384 945 3840 10395 46080
=={{header|Ring}}==
degree 3: 1 2 3 4 10 18 28 80 162 280 880 1944
<syntaxhighlight lang="ring">
degree 4: 1 2 3 4 5 12 21 32 45 120 231 384
see "Degree " + "|" + " Multifactorials 1 to 10" + nl
degree 5: 1 2 3 4 5 6 14 24 36 50 66 168
see copy("-", 52) + nl
degree 6: 1 2 3 4 5 6 7 16 27 40 55 72
for d = 1 to 5
degree 7: 1 2 3 4 5 6 7 8 18 30 44 60
degree 8: 1see 2"" 3+ 4d 5+ 6" 7 8 9 20 33 48 " + "| "
degree 9: 1for 2n 3= 41 5 6 7 8 9to 10 22 36
degree 10: 1 2 3 4 5 6see 7"" 8+ 9multiFact(n, 10d) 11+ 24" "
next
see nl
next
 
func multiFact n, degree
fact = 1
for i = n to 2 step -degree
fact = fact * i
next
return fact
</syntaxhighlight>
Output:
<pre>
Degree | Multifactorials 1 to 10
----------------------------------------------------
1 | 1 2 6 24 120 720 5040 40320 362880 3628800
2 | 1 2 3 8 15 48 105 384 945 3840
3 | 1 2 3 4 10 18 28 80 162 280
4 | 1 2 3 4 5 12 21 32 45 120
5 | 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|RPL}}==
Recursivity is the simplest way to implement the task in RPL.
{{works with|Halcyon Calc|4.2.7}}
===Recursive===
≪ IF DUP2 > THEN DUP2 - SWAP NFACT * ELSE DROP END ≫
'NFACT' STO
===Iterative===
≪ OVER
WHILE DUP2 < REPEAT OVER - DUP 4 ROLL * ROT ROT END
DROP2
≫
'NFACT' STO
 
≪ 1 5 FOR p
{ } 1 10 FOR n
n p NFACT +
NEXT NEXT
≫ EVAL
{{out}}
<pre>
5: { 1 2 6 24 120 720 5040 40320 362880 3628800 }
4: { 1 2 3 8 15 48 105 384 945 3840 }
3: { 1 2 3 4 10 18 28 80 162 280 }
2: { 1 2 3 4 5 12 21 32 45 120 }
1: { 1 2 3 4 5 6 14 24 36 50 }
</pre>
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">def multifact(n, d)
<lang ruby>
def multifact(n, d)
n.step(1, -d).inject( :* )
end
 
(1..5).each {|d| puts "Degree #{d}: #{(1..10).map{|n| multifact(n, d)}.join "\t"}"}</syntaxhighlight>
</lang>
'''output'''
<pre style="overflow:scroll">
Line 551 ⟶ 2,261:
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">
print "Degree " + "|" + " Multifactorials 1 to 10" + nl
print copy("-", 52) + nl
for d = 1 to 5
print "" + d + " " + "| "
for n = 1 to 10
print "" + multiFact(n, d) + " ";
next
print
next
function multiFact(n,degree)
fact = 1
for i = n to 2 step -degree
fact = fact * i
next
multiFact = fact
end function</syntaxhighlight>
<pre>Degree | Multifactorials 1 to 10
--------|---------------------------------------------
1 | 1 2 6 24 120 720 5040 40320 362880 3628800
2 | 1 2 3 8 15 48 105 384 945 3840
3 | 1 2 3 4 10 18 28 80 162 280
4 | 1 2 3 4 5 12 21 32 45 120
5 | 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn multifactorial(n: i32, deg: i32) -> i32 {
if n < 1 {
1
} else {
n * multifactorial(n - deg, deg)
}
}
 
fn main() {
for i in 1..6 {
for j in 1..11 {
print!("{} ", multifactorial(j, i));
}
println!("");
}
}</syntaxhighlight>
<pre>
1 2 6 24 120 720 5040 40320 362880 3628800
1 2 3 8 15 48 105 384 945 3840
1 2 3 4 10 18 28 80 162 280
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Scala}}==
<syntaxhighlight lang="scala">
def multiFact(n : BigInt, degree : BigInt) = (n to 1 by -degree).product
 
for{
degree <- 1 to 5
str = (1 to 10).map(n => multiFact(n, degree)).mkString(" ")
} println(s"Degree $degree: $str")
</syntaxhighlight>
 
{{out}}
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Scheme}}==
 
<syntaxhighlight lang="scheme">
(import (scheme base)
(scheme write)
(srfi 1))
 
(define (multi-factorial n m)
(fold * 1 (iota (ceiling (/ n m)) n (- m))))
 
(for-each
(lambda (degree)
(display (string-append "degree "
(number->string degree)
": "))
(for-each
(lambda (num)
(display (string-append (number->string (multi-factorial num degree))
" ")))
(iota 10 1))
(newline))
(iota 5 1))
</syntaxhighlight>
 
{{out}}
<pre>
degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
degree 2: 1 2 3 8 15 48 105 384 945 3840
degree 3: 1 2 3 4 10 18 28 80 162 280
degree 4: 1 2 3 4 5 12 21 32 45 120
degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func integer: multiFact (in var integer: num, in integer: degree) is func
result
var integer: multiFact is 1;
begin
while num > 1 do
multiFact *:= num;
num -:= degree;
end while;
end func;
 
const proc: main is func
local
var integer: degree is 0;
var integer: num is 0;
begin
for degree range 1 to 5 do
write("Degree " <& degree <& ": ");
for num range 1 to 10 do
write(multiFact(num, degree) <& " ");
end for;
writeln;
end for;
end func;</syntaxhighlight>
 
{{out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program multifactorial;
loop for d in [1..5] do
print(d, ":", [multifac(n, d) : n in [1..10]]);
end loop;
 
proc multifac(n, d);
return */{n, (n-d)..1};
end proc;
end program;</syntaxhighlight>
{{out}}
<pre>1 : [1 2 6 24 120 720 5040 40320 362880 3628800]
2 : [1 2 3 8 15 48 105 384 945 3840]
3 : [1 2 3 4 10 18 28 80 162 280]
4 : [1 2 3 4 5 12 21 32 45 120]
5 : [1 2 3 4 5 6 14 24 36 50]</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func mfact(s, n) {
n > 0 ? (n * mfact(s, n-s)) : 1
}
 
{ |s|
say "step=#{s}: #{{|n| mfact(s, n)}.map(1..10).join(' ')}"
} << 1..10</syntaxhighlight>
{{out}}
<pre>
step=1: 1 2 6 24 120 720 5040 40320 362880 3628800
step=2: 1 2 3 8 15 48 105 384 945 3840
step=3: 1 2 3 4 10 18 28 80 162 280
step=4: 1 2 3 4 5 12 21 32 45 120
step=5: 1 2 3 4 5 6 14 24 36 50
step=6: 1 2 3 4 5 6 7 16 27 40
step=7: 1 2 3 4 5 6 7 8 18 30
step=8: 1 2 3 4 5 6 7 8 9 20
step=9: 1 2 3 4 5 6 7 8 9 10
step=10: 1 2 3 4 5 6 7 8 9 10
</pre>
 
=={{header|Swift}}==
 
<syntaxhighlight lang="swift">func multiFactorial(_ n: Int, k: Int) -> Int {
return stride(from: n, to: 0, by: -k).reduce(1, *)
}
 
let multis = (1...5).map({degree in
(1...10).map({member in
multiFactorial(member, k: degree)
})
})
 
for (i, degree) in multis.enumerated() {
print("Degree \(i + 1): \(degree)")
}</syntaxhighlight>
 
{{out}}
<pre>Degree 1: [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]
Degree 2: [1, 2, 3, 8, 15, 48, 105, 384, 945, 3840]
Degree 3: [1, 2, 3, 4, 10, 18, 28, 80, 162, 280]
Degree 4: [1, 2, 3, 4, 5, 12, 21, 32, 45, 120]
Degree 5: [1, 2, 3, 4, 5, 6, 14, 24, 36, 50]</pre>
 
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<langsyntaxhighlight lang="tcl">package require Tcl 8.6
 
proc mfact {n m} {
Line 566 ⟶ 2,476:
foreach n {1 2 3 4 5 6 7 8 9 10} {
puts $n:[join [lmap m {1 2 3 4 5 6 7 8 9 10} {mfact $m $n}] ,]
}</langsyntaxhighlight>
{{out}}
<pre>
Line 579 ⟶ 2,489:
9:1,2,3,4,5,6,7,8,9,10
10:1,2,3,4,5,6,7,8,9,10
</pre>
 
=={{header|uBasic/4tH}}==
{{Trans|Run BASIC}}
<syntaxhighlight lang="text">print "Degree | Multifactorials 1 to 10"
for x = 1 to 53 : print "-"; : next : print
for d = 1 to 5
print d;" ";"| ";
for n = 1 to 10
print FUNC(_multiFact(n, d));" ";
next
print
next
 
end
 
_multiFact param (2)
local (2)
c@ = 1
for d@ = a@ to 2 step -b@
c@ = c@ * d@
next
return (c@)</syntaxhighlight>
{{Out}}
<pre>Degree | Multifactorials 1 to 10
-----------------------------------------------------
1 | 1 2 6 24 120 720 5040 40320 362880 3628800
2 | 1 2 3 8 15 48 105 384 945 3840
3 | 1 2 3 4 10 18 28 80 162 280
4 | 1 2 3 4 5 12 21 32 45 120
5 | 1 2 3 4 5 6 14 24 36 50
 
0 OK, 0:1063</pre>
 
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function multifactorial(n,d)
If n = 0 Then
multifactorial = 1
Else
For i = n To 1 Step -d
If i = n Then
multifactorial = n
Else
multifactorial = multifactorial * i
End If
Next
End If
End Function
 
For j = 1 To 5
WScript.StdOut.Write "Degree " & j & ": "
For k = 1 To 10
If k = 10 Then
WScript.StdOut.Write multifactorial(k,j)
Else
WScript.StdOut.Write multifactorial(k,j) & " "
End If
Next
WScript.StdOut.WriteLine
Next
</syntaxhighlight>
 
{{Out}}
<pre>
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|Wortel}}==
<syntaxhighlight lang="wortel">@let {
facd &[d n]?{<= n d n @prod@range[n 1 @-d]}
; tacit implementation
facdt ^(!?(/^> .1 ^(@prod @range ~1jdtShj &^!(@- @id))) @,)
; recursive
facdrec &[n d] ?{<= n d n *n !!facdrec -n d d}
; output
l @to 10
~@each @to 5 &n !console.log "Degree {n}: {@join @s !*\facd n l}"
}</syntaxhighlight>
Output
<pre>Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
Degree 2: 1 2 3 8 15 48 105 384 945 3840
Degree 3: 1 2 3 4 10 18 28 80 162 280
Degree 4: 1 2 3 4 5 12 21 32 45 120
Degree 5: 1 2 3 4 5 6 14 24 36 50</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
 
var mf = Fn.new { |n, d|
var prod = 1
while (n > 1) {
prod = prod * n
n = n - d
}
return prod
}
 
for (d in 1..5) {
System.write("degree %(d): ")
for (n in 1..10) System.write(Fmt.d(8, mf.call(n, d)))
System.print()
}</syntaxhighlight>
 
{{out}}
<pre>
degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800
degree 2: 1 2 3 8 15 48 105 384 945 3840
degree 3: 1 2 3 4 10 18 28 80 162 280
degree 4: 1 2 3 4 5 12 21 32 45 120
degree 5: 1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">code ChOut=8, CrLf=9, IntOut=11;
 
func MultiFac(N, D); \Return multifactorial of N in degree D
Line 599 ⟶ 2,625:
[IntOut(0, MultiFac(I, J)); ChOut(0, 9\tab\)];
CrLf(0);
]</langsyntaxhighlight>
 
{{out}}
Line 608 ⟶ 2,634:
1 2 3 4 5 12 21 32 45 120
1 2 3 4 5 6 14 24 36 50
</pre>
 
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn mfact(n,m){ [n..1,-m].reduce('*,1) }
foreach m in ([1..5]){ println("%d: %s".fmt(m,[1..10].apply(mfact.fp1(m)))) }</syntaxhighlight>
{{out}}
<pre>
1: L(1,2,6,24,120,720,5040,40320,362880,3628800)
2: L(1,2,3,8,15,48,105,384,945,3840)
3: L(1,2,3,4,10,18,28,80,162,280)
4: L(1,2,3,4,5,12,21,32,45,120)
5: L(1,2,3,4,5,6,14,24,36,50)
</pre>
PureFox
9,485

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/221542...351786"