Multifactorial

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

A generalization of this is the multifactorials where:

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

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

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

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

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

Where the products are for 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 to

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 1..10 members of the first five degrees of multifactorial.

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

C++

<lang cpp> /*Generate multifactorials to 9

 Nigel_Galloway
 November 14th., 2012.

/

int main(void) {

 for (int g = 1; g < 10; g++) {
   int v[12];
   for (int n = 1; n < 11; n++) {
     v[n] = (g < n)? v[n-g]*n : n;
     std::cout << v[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

D

<lang d>import std.stdio, std.algorithm, std.range;

T multifactorial(T=long)(in int n, in int m) /*pure*/ {

   T one = 1;
   return reduce!q{a * b}(one, iota(n, 0, -m));

}

void main() {

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

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

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.

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

Perl 6

<lang perl6>sub mfact($n, :$degree = 1) {

   [*] $n, $n - $degree ...^ * <= 0;

}

for 1 .. 5 -> $degree {

   say "$degree: ", map &mfact.assuming(:$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

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>

Tcl

Works with: Tcl version 8.6

<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

C++

D

Go

Haskell

Perl 6

Python

Python: Iterative

Python: Recursive

Tcl