Multifactorial

From Rosetta Code
Task
Multifactorial
You are encouraged to solve this task according to the task description, using any language you may know.

The factorial of a number, written as , is defined as .

Multifactorials generalize factorials as follows:

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

  1. Write a function that given n and the degree, calculates the multifactorial.
  2. Use the function to generate and display here a table of the first ten members (1 to 10) of the first five degrees of multifactorial.


Note: The wikipedia entry on multifactorials gives a different formula. This task uses the Wolfram mathworld definition.


360 Assembly[edit]

For maximum compatibility, this program uses only the basic instruction set (S/360 1964 POP).

*        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 [email protected]
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
Output:
       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

Ada[edit]

with Ada.Text_IO; use Ada.Text_IO;
procedure Mfact is
 
function MultiFact (num : Natural; deg : Positive) return Natural is
Result, N : Integer := num;
begin
if N = 0 then return 1; end if;
loop
N := N - deg; exit when N <= 0; Result := Result * N;
end loop; return Result;
end MultiFact;
 
begin
for deg in 1..5 loop
Put("Degree"& Integer'Image(deg) &":");
for num in 1..10 loop Put(Integer'Image(MultiFact(num,deg))); end loop;
New_line;
end loop;
end Mfact;
Output:
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

ALGOL 68[edit]

Translation of C.

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

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

AutoHotkey[edit]

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
}

Output:

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

C[edit]

Uses: C Runtime (Components:printf,)
 
/* Include statements and constant definitions */
#include <stdio.h>
#define HIGHEST_DEGREE 5
#define LARGEST_NUMBER 10
 
/* Recursive implementation of multifactorial function */
int multifact(int n, int deg){
return n <= deg ? n : n * multifact(n - deg, deg);
}
 
/* Iterative implementation of multifactorial function */
int multifact_i(int n, int deg){
int result = n;
while (n >= deg + 1){
result *= (n - deg);
n -= deg;
}
return result;
}
 
/* Test function to print out multifactorials */
int main(void){
int i, j;
for (i = 1; i <= HIGHEST_DEGREE; i++){
printf("\nDegree %d: ", i);
for (j = 1; j <= LARGEST_NUMBER; j++){
printf("%d ", multifact(j, i));
}
}
}
 
Output:
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

C#[edit]

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));
}
}
}

Output:

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

C++[edit]

 
#include <algorithm>
#include <iostream>
#include <iterator>
/*Generate multifactorials to 9
 
Nigel_Galloway
November 14th., 2012.
*/

int main(void) {
for (int g = 1; g < 10; g++) {
int v[11], n=0;
generate_n(std::ostream_iterator<int>(std::cout, " "), 10, [&]{n++; return v[n]=(g<n)? v[n-g]*n : n;});
std::cout << std::endl;
}
return 0;
}
 
Output:
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 3 4 5 6 7 16 27 40
1 2 3 4 5 6 7 8 18 30
1 2 3 4 5 6 7 8 9 20
1 2 3 4 5 6 7 8 9 10

Clojure[edit]

(defn !! [m n]
(->> (iterate #(- % m) n) (take-while pos?) (apply *)))
 
(doseq [m (range 1 6)]
(prn m (map #(!! m %) (range 1 11))))
Output:
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)

Common Lisp[edit]

 
(defun mfac (n m)
(reduce #'* (loop for i from n downto 1 by m collect i)))
 
(loop for i from 1 to 10
do (format t "[email protected]: ~{~a~^ ~}~%"
i (loop for j from 1 to 10
collect (mfac j i))))
 
Output:
 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
 6: 1 2 3 4 5 6 7 16 27 40
 7: 1 2 3 4 5 6 7 8 18 30
 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

D[edit]

import std.stdio, std.algorithm, std.range;
 
T multifactorial(T=long)(in int n, in int m) pure /*nothrow*/ {
T one = 1;
return reduce!q{a * b}(one, iota(n, 0, -m));
}
 
void main() {
foreach (immutable m; 1 .. 11)
writefln("%2d: %s", m, iota(1, 11)
.map!(n => multifactorial(n, m)));
}
Output:
 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 
 6: 1 2 3 4 5 6 7 16 27 40 
 7: 1 2 3 4 5 6 7 8 18 30 
 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 

Dart[edit]

 
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);
}
 

Elixir[edit]

Translation of: Erlang
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)
Output:
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]

Erlang[edit]

-module(multifac).   
-compile(export_all).
 
multifac(N,D) ->
lists:foldl(fun (X,P) -> X * P end, 1, lists:seq(N,1,-D)).
 
main() ->
Ds = lists:seq(1,5),
Ns = lists:seq(1,10),
lists:foreach(fun (D) ->
io:format("Degree ~b: ~p~n",[D, [ multifac(N,D) || N <- Ns]])
end, Ds).
Output:
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]
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]
ok

ERRE[edit]

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

F#[edit]

let rec mfact d = function
| n when n <= d -> n
| n -> n * mfact d (n-d)
 
[<EntryPoint>]
let main argv =
let (|UInt|_|) = System.UInt32.TryParse >> function | true, v -> Some v | false, _ -> None
let (maxDegree, maxN) =
match argv with
| [| UInt d; UInt n |] -> (int d, int n)
| [| UInt d |] -> (int d, 10)
| _ -> (5, 10)
let showFor d = List.init maxN (fun i -> mfact d (i+1)) |> printfn "%i: %A" d
ignore (List.init maxDegree (fun i -> showFor (i+1)))
0
 
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]

Forth[edit]

: !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 ;
Output:
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

Fortran[edit]

Works with: Fortran version 95 and later
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
Output:
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

FreeBASIC[edit]

' 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
Output:
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

FunL[edit]

def multifactorial( n, d ) = product( n..1 by -d )
 
for d <- 1..5
println( d, [multifactorial(i, d) | i <- 1..10] ))
Output:
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]

GAP[edit]

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 ] ]

Go[edit]

package main
 
import "fmt"
 
func multiFactorial(n, k int) int {
r := 1
for ; n > 1; n -= k {
r *= n
}
return r
}
 
func main() {
for k := 1; k <= 5; k++ {
fmt.Print("degree ", k, ":")
for n := 1; n <= 10; n++ {
fmt.Print(" ", multiFactorial(n, k))
}
fmt.Println()
}
}
Output:
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

Haskell[edit]

mulfac k = 1:s where s = [1 .. k] ++ zipWith (*) s [k+1..]
 
-- for single n
mulfac1 k n = product [n, n-k .. 1]
 
main = mapM_ (print . take 10 . tail . mulfac) [1..5]
Output:
[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]

Icon and Unicon[edit]

The following is Unicon specific but can be readily translated into Icon:

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

Sample run:

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

J[edit]

 
NB. tacit implementation of the recursive c function
NB. int multifact(int n,int deg){return n<=deg?n:n*multifact(n-deg,deg);}
 
multifact=: [`([ * - $: ])@.(<~)
(a:,<' degree'),multifact table >:i.10
┌─────────┬──────────────────────────────────────┐
│ │ degree │
├─────────┼──────────────────────────────────────┤
│multifact│ 1 2 3 4 5 6 7 8 9 10
├─────────┼──────────────────────────────────────┤
11 1 1 1 1 1 1 1 1 1
22 2 2 2 2 2 2 2 2 2
36 3 3 3 3 3 3 3 3 3
424 8 4 4 4 4 4 4 4 4
5120 15 10 5 5 5 5 5 5 5
6720 48 18 12 6 6 6 6 6 6
75040 105 28 21 14 7 7 7 7 7
840320 384 80 32 24 16 8 8 8 8
9362880 945 162 45 36 27 18 9 9 9
103628800 3840 280 120 50 40 30 20 10 10
└─────────┴──────────────────────────────────────┘
 

Java[edit]

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();
}
}
}
Output:
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

JavaScript[edit]

Iterative[edit]

Translation of: C
 
function multifact(n, deg){
var result = n;
while (n >= deg + 1){
result *= (n - deg);
n -= deg;
}
return result;
}
 
 
function test (n, deg) {
for (var i = 1; i <= deg; i ++) {
var results = '';
for (var j = 1; j <= n; j ++) {
results += multifact(j, i) + ' ';
}
console.log('Degree ' + i + ': ' + results);
}
}
 
Output:
 
test(10, 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
 

Recursive[edit]

Translation of: C
function multifact(n, deg){
return n <= deg ? n : n * multifact(n - deg, deg);
}

Template:Test

function test (n, deg) {
for (var i = 1; i <= deg; i ++) {
var results = '';
for (var j = 1; j <= n; j ++) {
results += multifact(j, i) + ' ';
}
console.log('Degree ' + i + ': ' + results);
}
}
Output:
 
test(10, 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

jq[edit]

Works with: jq version 1.4
# 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);
# 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)) )";

The specific task:

table(5; 10)
Output:
$ 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

Julia[edit]

multifact calculates the mulitfactorial function iteratively.

 
function multifact{T<:Integer,U<:Integer}(n::T, k::U)
-1<n && 0<k || throw(DomainError())
1 < k || return factorial(n)
r = one(T)
for i in n:-k:2
r *= i
end
return r
end
 
khi = 5
nhi = 10
println("Showing multifactorial for n in [1,", nhi, "] and k in [1,", khi, "].")
for k = 1:khi
a = Int64[multifact(i, k) for i in 1:nhi]
lab = "n"*"!"^k
println(@sprintf("  %-6s => ", lab), a)
end
 
Output:
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]

Kotlin[edit]

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()
}
}
Output:
    !: 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

Lua[edit]

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

Mathematica[edit]

Multifactorial[n_, m_] := Abs[ Apply[ Times, Range[-n, -1, m]]]
Table[ Multifactorial[j, i], {i, 5}, {j, 10}] // TableForm
Output:
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

МК-61/52[edit]

П1	<->	П0	П2	ИП0	ИП1	1	+	-	x>=0
23 ИП2 ИП0 ИП1 - * П2 ИП0 ИП1 -
П1 БП 04 ИП2 С/П

Instruction: number ^ degree В/О С/П

Nim[edit]

# Recursive
proc multifact(n, deg): int =
result = (if n <= deg: n else: n * multifact(n - deg, deg))
 
# Iterative
proc multifactI(n, deg): int =
result = n
var n = n
while n >= deg + 1:
result *= n - deg
n -= deg
 
for i in 1..5:
stdout.write "\nDegree ", i, ": "
for j in 1..10:
stdout.write multifactI(j, i), " "

Output:

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

Objeck[edit]

Translation of: C
 
class Multifact {
function : MultiFact(n : Int, deg : Int) ~ Int {
result := n;
while (n >= deg + 1){
result *= (n - deg);
n -= deg;
};
 
return result;
}
 
function : Main(args : String[]) ~ Nil {
for (i := 1; i <= 5; i+=1;){
IO.Console->Print("Degree ")->Print(i)->Print(": ");
for (j := 1; j <= 10; j+=1;){
IO.Console->Print(' ')->Print(MultiFact(j, i));
};
IO.Console->PrintLine();
};
}
}
 

Output:

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


Oforth[edit]

: 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 ] ;
Output:
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]

PARI/GP[edit]

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

Perl[edit]

{ # <-- scoping the cache and bigint clause
my @cache;
use bigint;
sub mfact {
my ($s, $n) = @_;
return 1 if $n <= 0;
$cache[$s][$n] //= $n * mfact($s, $n - $s);
}
}
 
for my $s (1 .. 10) {
print "step=$s: ";
print join(" ", map(mfact($s, $_), 1 .. 10)), "\n";
}
Output:
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

We can also do this iteratively. ntheory's vecprod makes bigint products if needed, so we don't have to worry about it.

Library: ntheory
use ntheory qw/vecprod/;
 
sub mfac {
my($n,$d) = @_;
vecprod(map { $n - $_*$d } 0 .. int(($n-1)/$d));
}
 
for my $degree (1..5) {
say "$degree: ",join(" ",map{mfac($_,$degree)} 1..10);
}
Output:
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

Perl 6[edit]

for 1 .. 5 -> $degree {
sub mfact($n) { [*] $n, *-$degree ...^ * <= 0 };
say "$degree: ", map &mfact, 1..10
}
Output:
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

Phix[edit]

function multifactorial(integer n, integer order)
atom res = 1
if n>0 then
res = n*multifactorial(n-order,order)
end if
return res
end function
 
sequence s = repeat(0,10)
for i=1 to 5 do
for j=1 to 10 do
s[j] = multifactorial(j,i)
end for
 ?s
end for
Output:
{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}

PicoLisp[edit]

Translation of: C
(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) )

Output:

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

PL/I[edit]

 
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;
 

Output:

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


Plain TeX[edit]

Works with an etex engine.

\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

Output pdf looks like:

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

Python[edit]

Python: Iterative[edit]

>>> from functools import reduce
>>> from operator import mul
>>> def mfac(n, m): return reduce(mul, range(n, 0, -m))
 
>>> for m in range(1, 11): print("%2i: %r" % (m, [mfac(n, m) for n in range(1, 11)]))
 
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]
6: [1, 2, 3, 4, 5, 6, 7, 16, 27, 40]
7: [1, 2, 3, 4, 5, 6, 7, 8, 18, 30]
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]
>>>

Python: Recursive[edit]

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

R[edit]

 
#x is Input
#n is Factorial Number
multifactorial=function(x,n){
if(x<=n+1){
return(x)
}else{
return(x*multifactorial(x-n,n))
}
}
 

Racket[edit]

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

Output:

'((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))

REXX[edit]

This version also handles zero as well as positive integers.

/*REXX program calculates and displays K-fact (multifactorial) of non-negative integers.*/
numeric digits 1000 /*get ka-razy with the decimal digits. */
parse arg num deg . /*get optional arguments from the C.L. */
if num=='' | num=="," then num=15 /*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) )':' _
end /*d*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
Kfact: procedure; !=1; do j=arg(1) to 2 by -word(arg(2) 1,1);  !=!*j; end; return !

output   when using the default input:

═══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
        n!!  [2]:  1 2 3 8 15 48 105 384 945 3840 10395 46080 135135 645120 2027025
       n!!!  [3]:  1 2 3 4 10 18 28 80 162 280 880 1944 3640 12320 29160
      n!!!!  [4]:  1 2 3 4 5 12 21 32 45 120 231 384 585 1680 3465
     n!!!!!  [5]:  1 2 3 4 5 6 14 24 36 50 66 168 312 504 750
    n!!!!!!  [6]:  1 2 3 4 5 6 7 16 27 40 55 72 91 224 405
   n!!!!!!!  [7]:  1 2 3 4 5 6 7 8 18 30 44 60 78 98 120
  n!!!!!!!!  [8]:  1 2 3 4 5 6 7 8 9 20 33 48 65 84 105
 n!!!!!!!!!  [9]:  1 2 3 4 5 6 7 8 9 10 22 36 52 70 90
n!!!!!!!!!! [10]:  1 2 3 4 5 6 7 8 9 10 11 24 39 56 75

Ring[edit]

 
see "Degree " + "|" + " Multifactorials 1 to 10" + nl
see copy("-", 52) + nl
for d = 1 to 5
see "" + d + " " + "| "
for n = 1 to 10
see "" + multiFact(n, d) + " "
next
see nl
next
 
func multiFact n, degree
fact = 1
for i = n to 2 step -degree
fact = fact * i
next
return fact
 

Output:

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

Ruby[edit]

 
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"}"}
 

output

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

Run BASIC[edit]

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

Scala[edit]

 
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")
 
Output:
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

Scheme[edit]

 
(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))
 
Output:
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 

Seed7[edit]

$ 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;
Output:
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 

Sidef[edit]

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

Tcl[edit]

Works with: Tcl version 8.6
package require Tcl 8.6
 
proc mfact {n m} {
set mm [expr {-$m}]
for {set r $n} {[incr n $mm] > 1} {set r [expr {$r * $n}]} {}
return $r
}
 
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}] ,]
}
Output:
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
6:1,2,3,4,5,6,7,16,27,40
7:1,2,3,4,5,6,7,8,18,30
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

uBasic/4tH[edit]

Translation of: Run BASIC
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@)
Output:
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

VBScript[edit]

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

Wortel[edit]

@let {
facd &[d n]?{<= n d n @[email protected][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
[email protected] @to 5 &n !console.log "Degree {n}: [email protected] @s !*\facd n l}"
}

Output

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

XPL0[edit]

code ChOut=8, CrLf=9, IntOut=11;
 
func MultiFac(N, D); \Return multifactorial of N in degree D
int N, D;
int F;
[F:= 1;
repeat F:= F*N;
N:= N-D;
until N <= 1;
return F;
];
 
int I, J; \generate table of multifactorials
for J:= 1 to 5 do
[for I:= 1 to 10 do
[IntOut(0, MultiFac(I, J)); ChOut(0, 9\tab\)];
CrLf(0);
]
Output:
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      

zkl[edit]

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)))) }
Output:
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)