Multifactorial: Difference between revisions

Content added Content deleted

Inline

Latest revision as of 14:12, 4 January 2024

The factorial of a number, written as $n!$ , is defined as $n!=n(n-1)(n-2)...(2)(1)$ .

Multifactorials generalize factorials as follows:

n!=n(n-1)(n-2)...(2)(1)

n!!=n(n-2)(n-4)...

n!!!=n(n-3)(n-6)...

n!!!!=n(n-4)(n-8)...

n!!!!!=n(n-5)(n-10)...

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:

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

11l

Translation of: Crystal

F multifact(n, d)
   R product((n .< 1).step(-d))

L(d) 1..5
   print(‘Degree ’d‘: ’(1..10).map(n -> multifact(n, @d)))

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]

Translation of: Wren

F multifact(=n, d)
   V prod = 1
   L n > 1
      prod *= n
      n -= d
   R prod

360 Assembly

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

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

Action!

Library: Action! Tool Kit

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

Output:

Screenshot from Atari 8-bit computer

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

Ada

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

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

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

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

ALGOL W

Iterative multifactorial based on Ada, AutoHotkey, etc.

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.

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

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

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"

Arturo

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

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

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

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

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

BASIC

ANSI BASIC

Translation of: FreeBASIC

Works with: Decimal 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

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

BBC BASIC

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%

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

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

BQN

MultiFact ← ×´⊣-↕∘⌈∘÷×⊢

MultiFact⌜⟜(5⊸↑) 1+↕10

Output:

┌─
╵       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
                          ┘

Uses: C Runtime (Components:{{#foreach: component$n$|{{{component$n$}}}Property "Uses Library" (as page type) with input value "Library/C Runtime/{{{component$n$}}}" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process., }})

/* 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#

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

#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

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

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

Output:

         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

Common Lisp

(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 "~2@a: ~{~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

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;

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

Crystal

Translation of: 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"}"}

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

D

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

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

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

Output:

         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

Delphi

Works with: Delphi version 6.0

Library: SysUtils,StdCtrls

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;

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

EasyLang

Translation of: AWK

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

Elixir

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

-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

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#

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]

Factor

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

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

Forth

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

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

' 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

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

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

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

mulfac :: (Num a, Enum a) => a -> [a]
mulfac k = 1 : s
  where
    s = [1 .. k] <> zipWith (*) s [k + 1 ..]

-- For single n:

mulfac1 :: (Num a, Enum a) => a -> a -> a
mulfac1 k n = product [n, n - k .. 1]

main :: IO ()
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

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

IS-BASIC

100 PROGRAM "Multifac.bas"
110 FOR I=1 TO 5
120   PRINT "Degree";I;":";
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

J

   NB. n multifact degree
   multifact=: */@([ - ] * i.@>.@%)&>
   ('';'       degree'),multifact table >:i.10
┌─────────┬──────────────────────────────────────┐
│         │       degree                         │
├─────────┼──────────────────────────────────────┤
│multifact│      1    2   3   4  5  6  7  8  9 10│
├─────────┼──────────────────────────────────────┤
│ 1       │      1    1   1   1  1  1  1  1  1  1│
│ 2       │      2    2   2   2  2  2  2  2  2  2│
│ 3       │      6    3   3   3  3  3  3  3  3  3│
│ 4       │     24    8   4   4  4  4  4  4  4  4│
│ 5       │    120   15  10   5  5  5  5  5  5  5│
│ 6       │    720   48  18  12  6  6  6  6  6  6│
│ 7       │   5040  105  28  21 14  7  7  7  7  7│
│ 8       │  40320  384  80  32 24 16  8  8  8  8│
│ 9       │ 362880  945 162  45 36 27 18  9  9  9│
│10       │3628800 3840 280 120 50 40 30 20 10 10│
└─────────┴──────────────────────────────────────┘

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

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

Iterative

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

Translation of: C

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

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

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

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

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

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

Lambdatalk

{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

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

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]

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

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

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

Output:

         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

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;

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]

Mathematica/Wolfram Language

Multifactorial[n_, d_] := Product[x, {x, n, 1, -d}]
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

Maxima

Using built-in function genfact

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

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]

min

Works with: min version 0.19.3

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

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

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

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

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

Instruction: number ^ degree В/О С/П

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

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

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

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

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

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

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]

Ol

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

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

By the way, we can create few multifactorial functions and use them directly or as part of infix math notation (inside "//" macro).

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

Output:

4959435223298761261056
4959435223298761261058

PARI/GP

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

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

Phix

with javascript_semantics
function multifactorial(integer n, 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
    pp(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}

Picat

Using prod/1

multifactorial(N,Degree) = prod([ I : I in N..-Degree..1]).

Using reduce/2

multifactorial2(N,Degree) = reduce(*, [I : I in N..-Degree..1]).

While loop

multifactorial3(N,Degree) = M => 
  M = 1, I = N,
  while(I > 0) 
    M := M*I,
    I := I - Degree
  end.

Recursive variants

multifactorial4(N,_D) = 1, N <= 0 => true.

multifactorial4(N,D) = N*multifactorial4(N-D,D).

multifactorial5(N,D) = M =>
 N <= 0 -> M = 1 ; M = N*multifactorial4(N-D,D).

multifactorial6(N,D) = cond(N <= 0, 1, N*multifactorial6(N-D,D)).

Test

import util.

go =>
  foreach(D in 1..15)
     println(D=[multifactorial(I,D) : I in 1..15])
  end,  
  nl.

Output:

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]

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

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.

Output:

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

PicoLisp

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

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 $T e X$

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

Python: Iterative

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

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

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 ]

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

R

Recursive solution

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

Sequence solution

This task doesn't use big enough numbers to need efficient code, so R can solve this very succinctly.

mFact <- function(n, deg) prod(seq(from = n, to = 1, by = -deg))
cat("Simple version:\n")
print(outer(1:10, 1:5, Vectorize(mFact)))

If we really insist on a pretty table, then we can add some names and transpose the output.

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

Output:

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

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

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

Raku

(formerly Perl 6)

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

REXX

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

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

RPL

Recursivity is the simplest way to implement the task in RPL.

Works with: Halcyon Calc version 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

Output:

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 }

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

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

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

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!("");
	}
}

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

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

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

(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

$ 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

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;

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]

Sidef

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

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

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]

Tcl

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

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

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

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

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

Wren

Library: Wren-fmt

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

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

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

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)