# Multifactorial

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

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

Multifactorials generalize factorials as follows:

${\displaystyle n!=n(n-1)(n-2)...(2)(1)}$
${\displaystyle n!!=n(n-2)(n-4)...}$
${\displaystyle n!!!=n(n-3)(n-6)...}$
${\displaystyle n!!!!=n(n-4)(n-8)...}$
${\displaystyle 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:

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

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

## 360 Assembly

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

*        Multifactorial            09/05/2016MULFACR  CSECT         USING MULFACR,13SAVEAR   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=1LOOPI    C     I,D          do i=1 to deg         BH    ELOOPI       leave i         LA    L,W+4          [email protected]         LA    J,1            j=1LOOPJ    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=jLOOPK    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 kELOOPK   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 jELOOPJ   WTO   MF=(E,W)         LA    I,1(I)         i=i+1         B     LOOPI        next iELOOPI   L     13,4(0,13)   epilog         LM    14,12,12(13) "         XR    15,15        "         BR    14           "N        DC    F'10'        numberD        DC    F'5'         degreeW        DC    0F,H'84',H'0',CL80' ' length,zero,textX        DS    CL12         tempY        DS    D            packed PL8I        EQU   6J        EQU   7K        EQU   8S        EQU   9RR       EQU   10           even reg of R for MR opcodeR        EQU   11L        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


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

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

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

Translation of FreeBASIC.

100 FUNCTION multiFactorial (n, degree)110    IF  n < 2 THEN 120       LET multiFactorial = 1130       EXIT FUNCTION140    END IF150    LET result = n160    FOR i = n - degree TO 2 STEP -degree170       LET result = result * i180    NEXT i190    LET multiFactorial = result200 END FUNCTION210220 FOR degree = 1 TO 5230    PRINT "Degree"; degree; " => ";240    FOR n = 1 TO 10250       PRINT multiFactorial(n, degree); " ";260    NEXT n270    PRINT 280 NEXT degree290 END

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

## BBC BASIC

REM >multifactFOR i% = 1 TO 5  PRINT "Degree "; i%; ":";  FOR j% = 1 TO 10    PRINT " ";FNmultifact(j%, i%);  NEXT  PRINTNEXTEND:DEF FNmultifact(n%, degree%)LOCAL i%, mfact%mfact% = 1FOR 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

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#

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)

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

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 

 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 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) endend 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=RESULTEND 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 FOREND 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 prettyprintsequences ;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 multifactorialend 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 resultEnd 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 PrintPrint "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


mulfac k = 1:s where s = [1 .. k] ++ zipWith (*) s [k+1..] -- for single nmulfac1 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

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 5120   PRINT "Degree";I;":";130   FOR N=1 TO 10140     PRINT MFACT(N,I);150   NEXT 160   PRINT 170 NEXT 180 DEF MFACT(N,D)190   NUMERIC I,RES200   IF N<2 THEN LET MFACT=1:EXIT DEF210   LET RES=N220   FOR I=N-D TO 2 STEP-D230     LET RES=RES*I240   NEXT 250   LET MFACT=RES260 END DEF

## J

# 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.jqDegree 1: 1 2 6 24 120 720 5040 40320 362880 3628800Degree 2: 1 2 3 8 15 48 105 384 945 3840Degree 3: 1 1 3 4 5 18 28 40 162 280Degree 4: 1 1 1 4 5 6 7 32 45 60Degree 5: 1 1 1 1 5 6 7 8 9 50 ## Julia 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 = 5const nhi = 10println("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 ## Lua function multiFact (n, degree) local fact = 1 for i = n, 2, -degree do fact = fact * i end return factend 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 ## Maple  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 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 П1 <-> П0 П2 ИП0 ИП1 1 + - x>=023 ИП2 ИП0 ИП1 - * П2 ИП0 ИП1 -П1 БП 04 ИП2 С/П Instruction: number ^ degree В/О С/П ## Nim # Recursiveproc multifact(n, deg): int = result = (if n <= deg: n else: n * multifact(n - deg, deg)) # Iterativeproc 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 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 : 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 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 ## 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 ## Phix function multifactorial(integer n, integer order)atom res = 1 if n>0 then res = n*multifactorial(n-order,order) end if return resend 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 ?send 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 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 TeX 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]>>>  ## R  #x is Input#n is Factorial Numbermultifactorial=function(x,n){ if(x<=n+1){ return(x) }else{ return(x*multifactorial(x-n,n)) }}  ## 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)) ## 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 ──►" numsay 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" + nlsee copy("-", 52) + nlfor d = 1 to 5 see "" + d + " " + "| " for n = 1 to 10 see "" + multiFact(n, d) + " " next see nlnext 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  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" + nlprint copy("-", 52) + nlfor d = 1 to 5 print "" + d + " " + "| " for n = 1 to 10 print "" + multiFact(n, d) + " "; next printnext 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  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  ## 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  ## 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 : printfor d = 1 to 5 print d;" ";"| "; for n = 1 to 10 print FUNC(_multiFact(n, d));" "; next printnext 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] nextreturn ([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  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 IfEnd 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.WriteLineNext  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 @[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 code ChOut=8, CrLf=9, IntOut=11; func MultiFac(N, D); \Return multifactorial of N in degree Dint N, D;int F;[F:= 1;repeat F:= F*N; N:= N-D;until N <= 1;return F;]; int I, J; \generate table of multifactorialsfor 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)