Multifactorial
You are encouraged to solve this task according to the task description, using any language you may know.
The factorial of a number, written as , is defined as .
Multifactorials generalize factorials as follows:
In all cases, the terms in the products are positive integers.
If we define the degree of the multifactorial as the difference in successive terms that are multiplied together for a multifactorial (the number of exclamation marks), then the task is twofold:
- 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
For maximum compatibility, this program uses only the basic instruction set (S/360 1964 POP). <lang 360asm>* Multifactorial 09/05/2016 MULFACR CSECT
USING MULFACR,13
SAVEAR B STM-SAVEAR(15)
DC 17F'0'
STM STM 14,12,12(13) prolog
ST 13,4(15) " ST 15,8(13) " LR 13,15 " LA I,1 i=1
LOOPI C I,D do i=1 to deg
BH ELOOPI leave i LA L,W+4 l=@p LA J,1 j=1
LOOPJ C J,N do j=1 to num
BH ELOOPJ leave j LA R,1 r=1 LCR S,I s=-i LR K,J k=j
LOOPK C K,=F'2' do k=j to 2 by s
BL ELOOPK leave k MR RR,K r=r*k AR K,S k=k+s B LOOPK next k
ELOOPK CVD R,Y pack r
MVC X,=XL12'402020202020202020202120' ed mask ED X,Y+2 edit r MVC 0(8,L),X+4 output r LA L,8(L) l=l+8 LA J,1(J) j=j+1 B LOOPJ next j
ELOOPJ WTO MF=(E,W)
LA I,1(I) i=i+1 B LOOPI next i
ELOOPI L 13,4(0,13) epilog
LM 14,12,12(13) " XR 15,15 " BR 14 "
N DC F'10' number D DC F'5' degree W DC 0F,H'84',H'0',CL80' ' length,zero,text X DS CL12 temp Y DS D packed PL8 I EQU 6 J EQU 7 K EQU 8 S EQU 9 RR EQU 10 even reg of R for MR opcode R EQU 11 L EQU 12
END MULFACR</lang>
- 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
<lang 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;</lang>
- 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
<lang aime>mf(integer a, n) {
integer o;
o = 1; do { o *= a; } while (0 < (a -= n));
o;
}
main(void) {
integer i, j;
i = 0; while ((i += 1) <= 5) { o_("degree ", i, ":"); j = 0; while ((j += 1) <= 10) { o_("\t", mf(j, i)); } o_("\n"); }
0;
}</lang>
- 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. <lang Algol68>BEGIN
INT highest degree = 5; INT largest number = 10;
CO Recursive implementation of multifactorial function CO
PROC multi fact = (INT n, deg) INT : (n <= deg | n | n * multi fact(n - deg, deg));
CO Iterative implementation of multifactorial function CO
PROC multi fact i = (INT n, deg) INT : BEGIN INT result := n, nn := n; WHILE (nn >= deg + 1) DO
result TIMESAB nn - deg; nn MINUSAB deg
OD; result END;
CO Print out multifactorials CO
FOR i TO highest degree DO printf (($l, "Degree ", g(0), ":"$, i)); FOR j TO largest number DO
printf (($xg(0)$, multi fact (j, i)))
OD OD
END </lang>
- 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. <lang algolw>begin
% returns the multifactorial of n with the specified degree % integer procedure multifactorial ( integer value n, degree ) ; begin integer mf, v; mf := v := n; while begin v := v - degree; v > 1 end do mf := mf * v; mf end multifactorial ;
% tests as per task % for degree := 1 until 5 do begin i_w := 1; s_w := 0; % output formatting % write( "Degree: ", degree, ":" ); for v := 1 until 10 do begin writeon( " ", multifactorial( v, degree ) ) end for_v end for_degree
end.</lang>
- 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.
<lang ANSI Standard 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</lang>
Arturo
<lang arturo>multifact: @(n deg){ if n <= deg { n } { n * [multifact n-deg deg] } }
loop 1..5 @(i){ prints "Degree " + i + ": " loop 1..10 @(j){ prints [multifact j i] + " " } print "" } </lang>
- 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
<lang AutoHotkey>Loop, 5 {
Output .= "Degree " (i := A_Index) ": " Loop, 10 Output .= MultiFact(A_Index, i) (A_Index = 10 ? "`n" : ", ")
} MsgBox, % Output
MultiFact(n, d) {
Result := n while 1 < n -= d Result *= n return, Result
}</lang> 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
<lang AWK>
- syntax: GAWK -f MULTIFACTORIAL.AWK
- converted from Go
BEGIN {
for (k=1; k<=5; k++) { printf("degree %d:",k) for (n=1; n<=10; n++) { printf(" %d",multi_factorial(n,k)) } printf("\n") } exit(0)
} function multi_factorial(n,k, r) {
r = 1 for (; n>1; n-=k) { r *= n } return(r)
} </lang>
- 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
<lang bbcbasic>REM >multifact FOR i% = 1 TO 5
PRINT "Degree "; i%; ":"; FOR j% = 1 TO 10 PRINT " ";FNmultifact(j%, i%); NEXT PRINT
NEXT END
DEF FNmultifact(n%, degree%) LOCAL i%, mfact% mfact% = 1 FOR i% = n% TO 1 STEP -degree%
mfact% = mfact% * i%
NEXT = mfact%</lang>
- 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
<lang c> /* 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)); } }
} </lang>
- 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#
<lang csharp>namespace RosettaCode.Multifactorial {
using System; using System.Linq;
internal static class Program { private static void Main() { Console.WriteLine(string.Join(Environment.NewLine, Enumerable.Range(1, 5) .Select( degree => string.Join(" ", Enumerable.Range(1, 10) .Select( number => Multifactorial(number, degree)))))); }
private static int Multifactorial(int number, int degree) { if (degree < 1) { throw new ArgumentOutOfRangeException("degree"); }
var count = 1 + (number - 1) / degree; if (count < 1) { throw new ArgumentOutOfRangeException("number"); }
return Enumerable.Range(0, count) .Aggregate(1, (accumulator, index) => accumulator * (number - degree * index)); } }
}</lang> 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++
<lang cpp>
- 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;
} </lang>
- 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
<lang Clojure>(defn !! [m n]
(->> (iterate #(- % m) n) (take-while pos?) (apply *)))
(doseq [m (range 1 6)]
(prn m (map #(!! m %) (range 1 11))))</lang>
- 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
<lang 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))))
</lang>
- 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
Crystal
<lang ruby>def multifact(n, d)
n.step(to: 1, by: -d).product
end
(1..5).each {|d| puts "Degree #{d}: #{(1..10).map{|n| multifact(n, d)}.join "\t"}"}</lang> 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
<lang 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)));
}</lang>
- 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
<lang dart> main() {
int n=5,d=3;
int z= fact(n,d); print('$n factorial of degree $d is $z'); for(var j=1;j<=5;j++) {
print('first 10 numbers of degree $j :'); for(var i=1;i<=10;i++) { int z=fact(i,j); print('$z');
}
print('\n');
} }
int fact(int a,int b) {
if(a<=b||a==0) return a; if(a>1) return a*fact((a-b),b);
} </lang>
Elixir
<lang elixir>defmodule RC do
def multifactorial(n,d) do Enum.take_every(n..1, d) |> Enum.reduce(1, fn x,p -> x*p end) end
end
Enum.each(1..5, fn d ->
multifac = for n <- 1..10, do: RC.multifactorial(n,d) IO.puts "Degree #{d}: #{inspect multifac}"
end)</lang>
- 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
<lang 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).</lang>
- Output:
<lang erlang>5> multifac:main(). Degree 1: [1,2,6,24,120,720,5040,40320,362880,3628800] Degree 2: [1,2,3,8,15,48,105,384,945,3840] 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</lang>
ERRE
<lang ERRE> PROGRAM MULTIFACTORIAL
PROCEDURE MULTI_FACT(NUM,DEG->MF)
RESULT=NUM N=NUM IF N=0 THEN MF=1 EXIT PROCEDURE END IF LOOP N-=DEG EXIT IF N<=0 RESULT*=N END LOOP MF=RESULT
END PROCEDURE
BEGIN
PRINT(CHR$(12);) FOR DEG=1 TO 10 DO PRINT("Degree";DEG;":";) FOR NUM=1 TO 10 DO MULTI_FACT(NUM,DEG->MF) PRINT(MF;) END FOR PRINT END FOR
END PROGRAM </lang>
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#
<lang fsharp>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
</lang>
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
<lang>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</lang>
- 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
<lang>: !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 ;</lang>
- 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
<lang fortran>program test
implicit none integer :: i, j, n
do i = 1, 5 write(*, "(a, i0, a)", advance = "no") "Degree ", i, ": " do j = 1, 10 n = multifactorial(j, i) write(*, "(i0, 1x)", advance = "no") n end do write(*,*) end do
contains
function multifactorial (range, degree)
integer :: multifactorial, range, degree integer :: k multifactorial = product((/(k, k=range, 1, -degree)/))
end function multifactorial end program test</lang>
- 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
<lang freebasic>' FB 1.05.0 Win64
Function multiFactorial (n As UInteger, degree As Integer) As UInteger
If n < 2 Then Return 1 Var result = n For i As Integer = n - degree To 2 Step -degree result *= i Next Return result
End Function
For degree As Integer = 1 To 5
Print "Degree"; degree; " => "; For n As Integer = 1 To 10 Print multiFactorial(n, degree); " "; Next n Print
Next degree
Print Print "Press any key to quit" Sleep</lang>
- 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
<lang funl>def multifactorial( n, d ) = product( n..1 by -d )
for d <- 1..5
println( d, [multifactorial(i, d) | i <- 1..10] ))</lang>
- 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
<lang gap>MultiFactorial := function(n, k)
local r; r := 1; while n > 1 do r := r*n; n := n - k; od; return r;
end;
PrintArray(List([1 .. 10], n -> List([1 .. 5], k -> MultiFactorial(n, k)))); [ [ 1, 1, 1, 1, 1 ],
[ 2, 2, 2, 2, 2 ], [ 6, 3, 3, 3, 3 ], [ 24, 8, 4, 4, 4 ], [ 120, 15, 10, 5, 5 ], [ 720, 48, 18, 12, 6 ], [ 5040, 105, 28, 21, 14 ], [ 40320, 384, 80, 32, 24 ], [ 362880, 945, 162, 45, 36 ], [ 3628800, 3840, 280, 120, 50 ] ]</lang>
Go
<lang 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() }
}</lang>
- 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
<lang haskell>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]</lang>
- 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: <lang unicon>procedure main(A)
l := integer(A[1]) | 10 every writeRow(n := !l, [: mf(!10,n) :])
end
procedure writeRow(n, r)
writes(right(n,3),": ") every writes(right(!r,8)|"\n")
end
procedure mf(n, m)
if n <= 0 then return 1 return n*mf(n-m, m)
end</lang>
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
<lang 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</lang>
J
<lang J>
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│ └─────────┴──────────────────────────────────────┘ </lang>
Java
<lang java>public class MultiFact { private static long multiFact(long n, int deg){ long ans = 1; for(long i = n; i > 0; i -= deg){ ans *= i; } return ans; }
public static void main(String[] args){ for(int deg = 1; deg <= 5; deg++){ System.out.print("degree " + deg + ":"); for(long n = 1; n <= 10; n++){ System.out.print(" " + multiFact(n, deg)); } System.out.println(); } } }</lang>
- 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
<lang JavaScript> function multifact(n, deg){ var result = n; while (n >= deg + 1){ result *= (n - deg); n -= deg; } return result; } </lang>
<lang JavaScript> 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); } } </lang>
- Output:
<lang JavaScript> 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 </lang>
Recursive
<lang JavaScript>function multifact(n, deg){
return n <= deg ? n : n * multifact(n - deg, deg);
}</lang>
Test <lang JavaScript>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); }
}</lang>
- Output:
<lang JavaScript> 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 </lang>
jq
<lang jq># Input: n
- Output: n * (n - d) * (n - 2d) ...
def multifactorial(d):
. as $n | ($n / d | floor) as $k | reduce ($n - (d * range(0; $k))) as $i (1; . * $i);</lang>
<lang jq># Print out a d-by-n table of multifactorials neatly: def table(d; n):
def lpad(i): tostring | (i - length) * " " + .; def pp(stream): reduce stream as $i (""; . + ($i | lpad(8))); range(1; d+1) as $d | "Degree \($d): \( pp(range(1; n+1) | multifactorial($d)) )";</lang>
The specific task: <lang jq>table(5; 10)</lang>
- Output:
<lang sh>$ jq -n -r -f Multifactorial.jq Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800 Degree 2: 1 2 3 8 15 48 105 384 945 3840 Degree 3: 1 1 3 4 5 18 28 40 162 280 Degree 4: 1 1 1 4 5 6 7 32 45 60 Degree 5: 1 1 1 1 5 6 7 8 9 50</lang>
Julia
<lang julia>using Printf
function multifact(n::Integer, k::Integer)
n > 0 && k > 0 || throw(DomainError()) k > 1 || factorial(n) return prod(n:-k:2)
end
const khi = 5 const nhi = 10 println("Showing multifactorial for n in [1, $nhi] and k in [1, $khi].") for k = 1:khi
a = multifact.(1:nhi, k) lab = "n" * "!" ^ k @printf(" %-6s → %s\n", lab, a)
end</lang>
- 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
<lang scala>fun multifactorial(n: Long, d: Int) : Long {
val r = n % d return (1..n).filter { it % d == r } .reduce { i, p -> i * p }
}
fun main(args: Array<String>) {
val m = 5 val r = 1..10L for (d in 1..m) { print("%${m}s:".format( "!".repeat(d))) r.forEach { print(" " + multifactorial(it, d)) } println() }
}</lang>
- 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
<lang scheme> {def multifact
{lambda {:n :deg} {if {<= :n :deg} then :n else {* :n {multifact {- :n :deg} :deg}}}}}
-> multifact
{S.map {lambda {:deg} {br} Degree :deg: {S.map {{lambda {:deg :n} {multifact :n :deg}} :deg} {S.serie 1 10}}} {S.serie 1 5}} ->
Degree 1: 1 2 6 24 120 720 5040 40320 362880 3628800 Degree 2: 1 2 3 8 15 48 105 384 945 3840 Degree 3: 1 2 3 4 10 18 28 80 162 280 Degree 4: 1 2 3 4 5 12 21 32 45 120 Degree 5: 1 2 3 4 5 6 14 24 36 50
</lang>
Latitude
<lang latitude>use 'format importAllSigils.
multiFactorial := {
Range make ($1, 0, - $2) product.
}.
1 upto 6 visit {
takes '[degree]. answers := 1 upto 11 to (Array) map { multiFactorial ($1, degree). }. $stdout printf: ~fmt "Degree ~S: ~S", degree, answers.
}.</lang>
- 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
<lang Lua>function multiFact (n, degree)
local fact = 1 for i = n, 2, -degree do fact = fact * i end return fact
end
print("Degree\t|\tMultifactorials 1 to 10") print(string.rep("-", 52)) for d = 1, 5 do
io.write(" " .. d, "\t| ") for n = 1, 10 do io.write(multiFact(n, d) .. " ") end print()
end</lang>
- 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
<lang Maple>
f := proc (n, m)
local fac, i;
fac := 1;
for i from n by -m to 1 do
fac := fac*i;
end do;
return fac;
end proc:
a:=Matrix(5,10): for i from 1 to 5 do for j from 1 to 10 do a[i,j]:=f(j,i); end do; end do; a; </lang>
Mathematica
<lang mathematica>Multifactorial[n_, m_] := Abs[ Apply[ Times, Range[-n, -1, m]]] Table[ Multifactorial[j, i], {i, 5}, {j, 10}] // TableForm</lang>
- 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
min
<lang min>(:d (dup 0 <=) (pop 1) (dup d -) (*) linrec) :multifactorial (:d 1 (dup d multifactorial print! " " print! succ) 10 times newline pop) :row
1 (dup "Degree " print! print ": " print! row succ) 5 times</lang>
- 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
МК-61/52
<lang>П1 <-> П0 П2 ИП0 ИП1 1 + - x>=0 23 ИП2 ИП0 ИП1 - * П2 ИП0 ИП1 - П1 БП 04 ИП2 С/П</lang>
Instruction: number ^ degree В/О С/П
Nim
<lang nim># 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), " "</lang>
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
<lang objeck> 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(); }; }
} </lang>
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
<lang Oforth>: multifact(n, deg) 1 while( n 0 > ) [ n * n deg - ->n ] ;
- printMulti
| i |
5 loop: i [ System.Out i << " : " << 10 seq map(#[ i multifact]) << cr ] ;</lang>
- 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
<lang parigp>fac(n,d)=prod(k=0,(n-1)\d,n-k*d) for(k=1,5,for(n=1,10,print1(fac(n,k)" "));print)</lang>
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
<lang 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"; }</lang>
- 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.
<lang perl>use ntheory qw/vecprod/;
sub mfac {
my($n,$d) = @_; vecprod(map { $n - $_*$d } 0 .. int(($n-1)/$d));
}
for my $degree (1..5) {
say "$degree: ",join(" ",map{mfac($_,$degree)} 1..10);
}</lang>
- 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
<lang Phix>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</lang>
- 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
<lang PicoLisp>(de multifact (N Deg)
(let Res N (while (> N Deg) (setq Res (* Res (dec 'N Deg))) ) Res ) )
(for I 5
(prin "Degree " I ":") (for J 10 (prin " " (multifact J I)) ) (prinl) )</lang>
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
<lang> 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; </lang> 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.
<lang tex>\long\def\antefi#1#2\fi{#2\fi#1} \def\fornum#1=#2to#3(#4){% \edef#1{\number\numexpr#2}\edef\fornumtemp{\noexpand\fornumi\expandafter\noexpand\csname fornum\string#1\endcsname {\number\numexpr#3}{\ifnum\numexpr#4<0 <\else>\fi}{\number\numexpr#4}\noexpand#1}\fornumtemp } \long\def\fornumi#1#2#3#4#5#6{\def#1{\unless\ifnum#5#3#2\relax\antefi{#6\edef#5{\number\numexpr#5+(#4)\relax}#1}\fi}#1} \newcount\result \def\multifact#1#2{% \result=1 \fornum\multifactiter=#1 to 1(-#2){\multiply\result\multifactiter}% \number\result } \fornum\degree=1 to 5(+1){Degree \degree: \fornum\ii=1 to 10(+1){\multifact\ii\degree\space\space}\par} \bye</lang>
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
<lang python>>>> 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] >>> </lang>
Python: Recursive
<lang python>>>> def mfac2(n, m): return n if n <= (m + 1) else n * mfac2(n - m, m)
>>> for m in range(1, 6): print("%2i: %r" % (m, [mfac2(n, m) for n in range(1, 11)]))
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]
>>> </lang>
R
Recursive solution
<lang R>#x is Input
- n is Factorial Number
multifactorial=function(x,n){
if(x<=n+1){ return(x) }else{ return(x*multifactorial(x-n,n)) }
}</lang>
Sequence solution
This task doesn't use big enough numbers to need efficient code, so R can solve this very succinctly. <lang r>mfact<-function(n,deg){prod(seq(from = n, to = 1, by = -deg))} outer(1:10,1:5,Vectorize(mfact))</lang> If we really insist on a pretty table, then we can add some names and transpose the output. <lang r>mfact<-function(n,deg){prod(seq(from = n, to = 1, by = -deg))} n<-1:10; names(n)<-n deg<-1:5; names(deg)<-paste("Degree",deg) t(outer(n,deg,Vectorize(mfact)))</lang>
- Output:
> outer(1:10,1:5,Vectorize(mfact)) [,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 > t(outer(n,deg,Vectorize(mfact))) 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>#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)))</lang>
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) <lang perl6>for 1 .. 5 -> $degree {
sub mfact($n) { [*] $n, *-$degree ...^ * <= 0 }; say "$degree: ", map &mfact, 1..10
}</lang>
- 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. <lang rexx>/*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 !</lang> 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
<lang 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
</lang> 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
<lang ruby>def multifact(n, d)
n.step(1, -d).inject( :* )
end
(1..5).each {|d| puts "Degree #{d}: #{(1..10).map{|n| multifact(n, d)}.join "\t"}"}</lang> 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
<lang runbasic> print "Degree " + "|" + " Multifactorials 1 to 10" + nl print copy("-", 52) + nl for d = 1 to 5
print "" + d + " " + "| " for n = 1 to 10 print "" + multiFact(n, d) + " "; next print
next
function multiFact(n,degree)
fact = 1 for i = n to 2 step -degree fact = fact * i next multiFact = fact end function</lang>
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
<lang scala> def multiFact(n : BigInt, degree : BigInt) = (n to 1 by -degree).product
for{
degree <- 1 to 5 str = (1 to 10).map(n => multiFact(n, degree)).mkString(" ")
} println(s"Degree $degree: $str") </lang>
- 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
<lang scheme> (import (scheme base)
(scheme write) (srfi 1))
(define (multi-factorial n m)
(fold * 1 (iota (ceiling (/ n m)) n (- m))))
(for-each
(lambda (degree) (display (string-append "degree " (number->string degree) ": ")) (for-each (lambda (num) (display (string-append (number->string (multi-factorial num degree)) " "))) (iota 10 1)) (newline)) (iota 5 1))
</lang>
- 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
<lang seed7>$ include "seed7_05.s7i";
const func integer: multiFact (in var integer: num, in integer: degree) is func
result var integer: multiFact is 1; begin while num > 1 do multiFact *:= num; num -:= degree; end while; end func;
const proc: main is func
local var integer: degree is 0; var integer: num is 0; begin for degree range 1 to 5 do write("Degree " <& degree <& ": "); for num range 1 to 10 do write(multiFact(num, degree) <& " "); end for; writeln; end for; end func;</lang>
- 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
<lang ruby>func mfact(s, n) {
n > 0 ? (n * mfact(s, n-s)) : 1
}
{ |s|
say "step=#{s}: #{{|n| mfact(s, n)}.map(1..10).join(' ')}"
} << 1..10</lang>
- 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
<lang swift>func multiFactorial(_ n: Int, k: Int) -> Int {
return stride(from: n, to: 0, by: -k).reduce(1, *)
}
let multis = (1...5).map({degree in
(1...10).map({member in multiFactorial(member, k: degree) })
})
for (i, degree) in multis.enumerated() {
print("Degree \(i + 1): \(degree)")
}</lang>
- 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
<lang tcl>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}] ,]
}</lang>
- 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
<lang>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@)</lang>
- 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
<lang vb> Function multifactorial(n,d) If n = 0 Then multifactorial = 1 Else For i = n To 1 Step -d If i = n Then multifactorial = n Else multifactorial = multifactorial * i End If Next End If End Function
For j = 1 To 5 WScript.StdOut.Write "Degree " & j & ": " For k = 1 To 10 If k = 10 Then WScript.StdOut.Write multifactorial(k,j) Else WScript.StdOut.Write multifactorial(k,j) & " " End If Next WScript.StdOut.WriteLine Next </lang>
- 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
<lang wortel>@let {
facd &[d n]?{<= n d n @prod@range[n 1 @-d]} ; tacit implementation facdt ^(!?(/^> .1 ^(@prod @range ~1jdtShj &^!(@- @id))) @,) ; recursive facdrec &[n d] ?{<= n d n *n !!facdrec -n d d} ; output l @to 10 ~@each @to 5 &n !console.log "Degree {n}: {@join @s !*\facd n l}"
}</lang> 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
<lang ecmascript>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()
}</lang>
- 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
<lang 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); ]</lang>
- 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
<lang zkl>fcn mfact(n,m){ [n..1,-m].reduce('*,1) } foreach m in ([1..5]){ println("%d: %s".fmt(m,[1..10].apply(mfact.fp1(m)))) }</lang>
- 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)
- Programming Tasks
- Solutions by Programming Task
- 360 Assembly
- Ada
- Aime
- ALGOL 68
- ALGOL W
- ANSI Standard BASIC
- Arturo
- AutoHotkey
- AWK
- BBC BASIC
- C
- C Runtime
- C sharp
- C++
- Clojure
- Common Lisp
- Crystal
- D
- Dart
- Elixir
- Erlang
- ERRE
- F Sharp
- Factor
- Forth
- Fortran
- FreeBASIC
- FunL
- GAP
- Go
- Haskell
- Unicon
- IS-BASIC
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- Lambdatalk
- Latitude
- Lua
- Maple
- Maple examples needing attention
- Examples needing attention
- Mathematica
- Min
- МК-61/52
- Nim
- Objeck
- Oforth
- PARI/GP
- Perl
- Ntheory
- Phix
- PicoLisp
- PL/I
- PlainTeX
- Python
- R
- Racket
- Raku
- REXX
- Ring
- Ruby
- Run BASIC
- Scala
- Scheme
- Seed7
- Sidef
- Swift
- Tcl
- UBasic/4tH
- VBScript
- Wortel
- Wren
- Wren-fmt
- XPL0
- Zkl