Multifactorial

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

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:

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.

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

Aime[edit]

integer
mf(integer a, integer n)
{
    integer o;
 
    o = 1;
    do {
        o *= a;
    } while (0 < (a -= n));
 
    return o;
}
 
integer
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");
    }
 
    return 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[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

ALGOL W[edit]

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

ANSI Standard BASIC[edit]

Translation of FreeBASIC.

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

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

BBC BASIC[edit]

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

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]

Factor[edit]

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

IS-BASIC[edit]

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[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│
├─────────┼──────────────────────────────────────┤
│ 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[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);
}

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]

Works with: Julia version 0.6

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

This example does not show the output mentioned in the task description on this page (or a page linked to from here). Please ensure that it meets all task requirements and remove this message.
Note that phrases in task descriptions such as "print and display" and "print and show" for example, indicate that (reasonable length) output be a part of a language's solution.

 
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;

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 $T e X$ [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)
  [email protected] = 1
  for [email protected] = [email protected] to 2 step [email protected]
    [email protected] = [email protected] * [email protected]
  next
return ([email protected])

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}: {@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

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)

Multifactorial

Contents

360 Assembly[edit]

Ada[edit]

Aime[edit]

ALGOL 68[edit]

ALGOL W[edit]

ANSI Standard BASIC[edit]

AutoHotkey[edit]

BBC BASIC[edit]

C[edit]

C#[edit]

C++[edit]

Clojure[edit]

Common Lisp[edit]

D[edit]

Dart[edit]

Elixir[edit]

Erlang[edit]

ERRE[edit]

F#[edit]

Factor[edit]

Forth[edit]

Fortran[edit]

FreeBASIC[edit]

FunL[edit]

GAP[edit]

Go[edit]

Haskell[edit]

Icon and Unicon[edit]

IS-BASIC[edit]

J[edit]

Java[edit]

JavaScript[edit]

Iterative[edit]

Recursive[edit]

jq[edit]

Julia[edit]

Kotlin[edit]

Lua[edit]

Maple[edit]

Mathematica[edit]

МК-61/52[edit]

Nim[edit]

Objeck[edit]

Oforth[edit]

PARI/GP[edit]

Perl[edit]

Perl 6[edit]

Phix[edit]

PicoLisp[edit]

PL/I[edit]

Plain TeX[edit]

Python[edit]

Python: Iterative[edit]

Python: Recursive[edit]

R[edit]

Racket[edit]

REXX[edit]

Ring[edit]

Ruby[edit]

Run BASIC[edit]

Scala[edit]

Scheme[edit]

Seed7[edit]

Sidef[edit]

Tcl[edit]

uBasic/4tH[edit]

VBScript[edit]

Wortel[edit]

XPL0[edit]

zkl[edit]

Plain $T e X$ [edit]