[Question]
  [
Time for another easy challenge in which all can participate!
The multinomial theorem states:
$$(x\_1 + x\_2 + \cdots + x\_m)^n = \sum\_{k\_1 + k\_2 + \cdots + k\_m = n} \binom n {k\_1, k\_2, \dots, k\_m} \prod\_{1 \le t \le m} x\_t^{k\_t}.$$
The expression in parentheses is the multinomial coefficient, defined as:
$$\binom n {k\_1, k\_2, \dots, k\_m} = \frac {n!} {k\_1!k\_2!\cdots k\_m!}$$
Allowing the terms \$k\_i\$ to range over all integer partitions of \$n\$ gives the \$n\$-th level of Pascal's \$m\$-simplex. Your task is to compute this coefficient.
## Task
Write a program or function which takes \$m\$ numbers, \$n, k\_{1}, k\_{2}, \dots, k\_{m-1}\$, and outputs or returns the corresponding multinomial coefficient. Your program may optionally take \$m\$ as an additional argument if need be. Note that **\$k\_m\$ is not in the input.**
* These numbers may be input in any format one likes, for instance grouped into lists or encoded in unary, or anything else, as long as the actual computation of the multinomial coefficient is performed by your code, and not the encoding process.
* Output format is similarly flexible.
* All code should run in less than one minute for \$n\$ and \$m\$ up to 1000.
* Do not worry about integer overflow.
* Built-ins designed to compute the multinomial coefficient are not allowed.
* Standard loopholes apply.
## Scoring
This is code golf: Shortest solution in bytes wins.
## Test cases
```
Input: 3, [2, 0]
Output: 3
Input: 3, [1, 1]
Output: 6
Input: 11, [1, 4, 4]
Output: 34650
Input: 4, [1,2]
Output: 12
Input: 15, [5,4,3,2]
Output: 37837800
Input: 95, [65,4,4]
Output: 1934550571913396675776550070308250
Input: 32, [2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
Output: 4015057936610313875842560000000
Input: 15, [3,3,3,3]
Output: 168168000
Input: 1000, [10,10,10,10,10,10,10,10,10,10,100,100,100,100,100,100,100,100]
Output: 1892260836114766064839886173072628322819837473493540916521650371620708316292211493005889278395285403318471457333959691477413845818795311980925098433545057962732816261282589926581281484274178579110373517415585990780259179555579119249444675675971136703240347768185200859583936041679096016595989605569764359198616300820217344233610087468418992008471158382363562679752612394898708988062100932765563185864346460326847538659268068471585720069159997090290904151003744735224635733011050421493330583941651019570222984959183118891461330718594645532241449810403071583062752945668937388999711726969103987467123014208575736645381474142475995771446030088717454857668814925642941036383273459178373839445456712918381796599882439216894107889251444932486362309407245949950539480089149687317762667940531452670088934094510294534762190299611806466111882595667632800995865129329156425174586491525505695534290243513946995156554997365435062121633281021210807821617604582625046557789259061566742237246102255343862644466345335421894369143319723958653232683916869615649006682399919540931573841920000000000000
Input: 33, [17]
Output: 1166803110
Input: 55, [28]
Output: 3824345300380220
```
  
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~7~~ 6 bytes
```
;_/!:/
```
Look ma, no Unicode! This program takes a single list as input, with **n** at its first index.
[Try it online!](http://jelly.tryitonline.net/#code=O18vITov&input=&args=MTAwMCwgMTAsIDEwLCAxMCwgMTAsIDEwLCAxMCwgMTAsIDEwLCAxMCwgMTAsIDEwMCwgMTAwLCAxMDAsIDEwMCwgMTAwLCAxMDAsIDEwMCwgMTAw) or [verify all test cases at once](http://jelly.tryitonline.net/#code=O18vITovCsOH4oKsauKBtw&input=&args=WzMsIDIsIDBdLCBbMywgMSwgMV0sIFsxMSwgMSwgNCwgNF0sIFs0LCAxLCAyXSwgWzE1LCA1LCA0LCAzLCAyXSwgWzk1LCA2NSwgNCwgNF0sIFszMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMiwgMl0sIFsxNSwgMywgMywgMywgM10sIFsxMDAwLCAxMCwgMTAsIDEwLCAxMCwgMTAsIDEwLCAxMCwgMTAsIDEwLCAxMCwgMTAwLCAxMDAsIDEwMCwgMTAwLCAxMDAsIDEwMCwgMTAwLCAxMDBdLCBbMzMsIDE3XSwgWzU1LCAyOF0).
### How it works
```
;_/!:/ Input: A (list)
 _/    Reduce A by subtraction. This subtracts all other elements from the first.
;      Concatenate A with the result to the right.
   !   Apply factorial to all numbers in the resulting list.
    :/ Reduce the result by division. This divides the first element by the others.
```
[Answer]
## CJam, 11 bytes
```
l~_:-+:m!:/
```
Input as a single list with `n` first:
```
[95 65 4 4]
```
This handles inputs up to `n` and `m` 1000 pretty much instantly.
[Test it here.](http://cjam.aditsu.net/#code=l~_%3A-%2B%3Am!%3A%2F&input=%5B95%2065%204%204%5D)
### Explanation
```
l~  e# Read a line of input and evaluate it.
_   e# Duplicate.
:-  e# Fold subtraction over the list. A fold is essentially a foreach loop that starts
    e# from the second element. Hence, this subtracts all the k_i from n, giving k_m.
+   e# Append k_m to the list.
:m! e# Compute the factorial of each element in the list.
:/  e# Fold division over the list. Again, this divides n! by each of the k_i!.
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 21 ~~15~~ bytes
Let's put the [log-gamma function](http://mathworld.wolfram.com/LogGammaFunction.html) to good use. This avoids internal overflowing by working with logarithms of factorials, not with factorials themselves.
```
1+ZgiO$Gs-h1+Zgs-ZeYo
```
This works in [current version (9.2.2)](https://github.com/lmendo/MATL/releases/tag/9.2.2) of the language/compiler, which is earlier than this challenge.
Inputs are: first a number, then a numeric vector. The result is produced as a `double`, which limits maximum output to somewhere around `2^52`.
### Example
```
>> matl 1+ZgiO$Gs-h1+Zgs-ZeYo
> 15
> [5 4 3 2]
37837800
```
### Explanation
```
1+       % implicit input (number). Add 1
Zg       % log-gamma function
i        % input (numeric vector).
0$G      % push both inputs
s-       % sum the second input (vector) and subtract from first
h1+      % append to vector. Add 1
Zg       % log-gamma function, element-wise on extended vector
s        % sum of results
-        % subtract from previous result of log-gamma
Ze       % exponential
Yo       % round. Implicit display
```
[Answer]
## PowerShell, ~~91~~ 74 bytes
Woo! My 100th answer on PPCG!
```
param($n,$k)(1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)
```
Whew. Not going to win shortest-code, that's for sure. Uses a couple neat tricks with ranges, though. And this is probably complete gibberish to anyone not familiar with PowerShell.
### Explanation
First we take input with `param($n,$k)` and expect `$k` to be an array, e.g. `.\compute-the-multinomial-coefficient.ps1 11 @(1,4,4)`.
We'll start with the numerator (everything to the left of `/`). That's simply a range from `1..$n` that has been `-join`ed together with `*` and then evaluated with `iex` to compute the factorial (i.e., `1*2*3*...*$n`).
Next, we loop over `$k|%{...}` and each iteration we subtract the current value `$_` from `$n` (which we don't care about anymore) to formulate `$k_m` later. Additionally, we generate the range `1..$k_i` each iteration, which gets left on the pipeline. Those pipeline objects get array-concatenated with the second expression, range `1..$n` (which is `$k_m` at this point). All of that is finally `-join`ed together with `*` and evaluated with `iex`, similar to the numerator (this works because `x! * y! = 1*2*3*...*x * 1*2*3*...*y`, so we don't care about individual ordering).
Finally, the `/` happens, the numerator is divided by the denominator, and output.
Handles output correctly for larger numbers, since we're not explicitly casting any variables as any particular datatypes, so PowerShell will silently re-cast as different datatypes on the fly as needed. For the larger numbers, outputs via scientific notation to best preserve significant figures as the datatypes get re-cast. For example, `.\compute-the-multinomial-coefficient.ps1 55 @(28)` will output `3.82434530038022E+15`. I'm presuming this to be OK given *"Output format is similarly flexible"* is specified in the challenge and quintopia's comments *"If the final result can fit within the natively supported integer types, then the result must be accurate. If it cannot, there is no restriction on what may be output."*
---
### Alternatively
Depending upon output formatting decisions, the following at **92 bytes**
```
param($n,$k)((1..$n-join'*'|iex)/(($k|%{$n-=$_;1..$_})+(1..$n)-join'*'|iex)).ToString('G17')
```
Which is the same as the above, just uses [explicit output formatting](https://msdn.microsoft.com/en-us/library/kfsatb94(v=vs.110).aspx) with `.ToString('G17')` to achieve the desired number of digits. For `55 @(28)` this will output `3824345300380220.5`
---
Edit1 -- Saved 17 bytes by getting rid of `$d` and just calculating it directly, and getting rid of the calculation for `$k_m` by stringing it along while we loop `$k`  
Edit2 -- Added alternate version with explicit formatting
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 9 bytes
```
√ó/2!/+\‚çõ,
```
[Try it online!](https://tio.run/##LYw9CsJAEIX7PcVaa8j@aiysBNHKkFimCeSnCWphoYiVkEJYUUQsvIBdGm0s9SZzkThZbN689@abiZeFk2ziYpE76XqVzpM0qeF49X2KOgqgPElFufB69ffmipbbjsDcO3WGCzBHZCZTOOw/lYTyjCkMhqiz8SSsc0QyMI/BFi/BvFpg3k47@lQcygvrYLMjkuZUUGYnp5xwbo2iiijrBOEajcZKYug3oastIEVDaDDPP6TQSsIZY82CUc9FwUikfd8juqGE9wM "APL (Dyalog Extended) ‚Äì Try It Online")
Using the idea from [my APL answer on another challenge that involves multinomials](https://codegolf.stackexchange.com/a/196373/78410).
A tacit function whose left argument is the list of k's, and right argument is n. The test cases check if it agrees with [Adam's solution](https://codegolf.stackexchange.com/a/153924/78410) with left and right arguments flipped.
### How it works
```
√ó/2!/+\‚çõ,
     +\    ‚çù Cumulative sum of k's (up to m-1'th element)
       ‚çõ,  ‚çù Append n (sum of k_1 to k_m)
  2!/      ‚çù Binomial of consecutive pairs
√ó/         ‚çù Product
```
$$
\frac{(k\_1 + k\_2 + \cdots + k\_m)!}{k\_1! k\_2! \cdots k\_m!} = \frac{(k\_1 + k\_2)!}{k\_1! k\_2!} \times \frac{(k\_1 + k\_2 + \cdots + k\_m)!}{(k\_1 + k\_2)! k\_3! \cdots k\_m!}
$$
$$
= \frac{(k\_1 + k\_2)!}{k\_1! k\_2!} \times \frac{(k\_1 + k\_2 + k\_3)!}{(k\_1 + k\_2)! k\_3!} \times \frac{(k\_1 + k\_2 + \cdots + k\_m)!}{(k\_1 + k\_2 + k\_3)! \cdots k\_m!}
$$
$$
= \cdots = \binom{k\_1 + k\_2}{k\_1} \binom{k\_1 + k\_2 + k\_3}{k\_1 + k\_2} \cdots \binom{k\_1 + \cdots + k\_m}{k\_1 + \cdots + k\_{m-1}}
$$
[Answer]
# Mathematica, 26 bytes
```
#!/Times@@({#-+##2,##2}!)&
```
Example:
```
In[1]:= #!/Times@@({#-+##2,##2}!)&[95,65,4,4]
Out[1]= 1934550571913396675776550070308250
```
[Answer]
# Python 3, ~~93~~ 91
Thanks to [Dennis](https://codegolf.stackexchange.com/users/12012/dennis) and [FryAmTheEggman](https://codegolf.stackexchange.com/users/31625/fryamtheeggman).
```
f=lambda x:0**x or x*f(x-1)
def g(n,k):
    r=f(n)
    for i in k:r//=f(i)
    return r//f(n-sum(k))
```
`n` as integer, `k` as iterable.
Ungolfed:
```
import functools #cache
@functools.lru_cache(maxsize=None) #cache results to speed up calculations
def factorial(x):
    if x <= 1: return 1
    else: return x * factorial(x-1)
def multinomial(n, k):
    ret = factorial(n)
    for i in k: ret //= factorial(i)
    km = n - sum(k)
    return ret//factorial(km)
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte charater set")
Entirely based on the mathematical skill of [my colleague Marshall](http://www.dyalog.com/meet-team-dyalog.htm#Marshall).
Anonymous infix function. Takes *k* as right argument and *n* as left argument.
```
{√ó/‚çµ!‚ç∫-+\¬Ø1‚Üì0,‚çµ}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qQIACkHQLetQ2wdhEwdDIwvx/GpBdfXi6/qPerYqPenfpasccWm/4qG2ygQ5QpPb/f2OFNAUjBQMuEG2oYMhlaAhmmCiYcJmAWUZchqZAhilQyBjIsQRxzEzBCoyNQCpMH/VugSoyATKNuQwNDAxAEgYKFvpAAsjlMgYbb85lClJlZAEA "APL (Dyalog Unicode) ‚Äì Try It Online")
`{`‚Ä¶`}`‚ÄÉanonymous lambda; `‚ç∫` is left argument (*n*) and `‚çµ` is right argument (*k*)
‚ÄÉ`0,‚çµ`‚ÄÉprepend a zero to *k*
‚ÄÉ`¬Ø1‚Üì`‚ÄÉdrop the last item from that
‚ÄÉ`+\`‚ÄÉcumulative sum of that
‚ÄÉ`‚ç∫-`‚ÄÉsubtract that from *n*
‚ÄÉ`‚çµ!`‚ÄÉ(*k*) that
‚ÄÉ`√ó/`‚ÄÉproduct of that
[Answer]
## PARI/GP, 43 bytes
Pretty straightforward; aside from formatting, the ungolfed version might well be identical.
```
m(n,v)=n!/prod(i=1,#v,v[i]!)/(n-vecsum(v))!
```
[Answer]
# Matlab 48 bytes
You need to set `format` to `long` in advance to get the higher precision. Then, it's quite straightforward:
```
@(n,k)factorial(n)/prod(factorial([k,n-sum(k)]))
ans(95, [65,4,4])
ans =
 1.934550571913395e+33
```
[Answer]
# Pyth, 10 bytes
```
/F.!MaQ-FQ
```
Try it online: [Demonstration](http://pyth.herokuapp.com/?code=%2FF.!MaQ-FQ&input=[95%2C%2065%2C4%2C4]&debug=0)
### Explanation:
```
/F.!MaQ-FQ   implicit: Q = input list
       -FQ   reduce Q by subtraction
     aQ      append the result to Q
  .!M        compute the factorial for each number
/F           reduce by division
```
[Answer]
# J, 16 bytes
```
[(%*/)&:!],(-+/)
```
## Usage
For larger values, a suffix of `x` is used to denote extended precision integers.
```
   f =: [(%*/)&:!],(-+/)
   11 f 1 4 4
34650
   15x f 5 4 3 2
37837800
```
## Explanation
```
[(%*/)&:!],(-+/)  Input: n on LHS, A on RHS
             +/   Reduce A using addition
            -     Subtract that sum from n, this is the missing term
         ]        Get A
          ,       Append the missing term to A to make A'
[                 Get n
      &:!         Take the factorial of n and each value in A'
   */             Reduce using multiplication the factorials of A'
  %               Divide n! by that product and return
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
```
√Ü¬∏¬´!R.¬´√∑
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cNuhHYdWKwbpHVp9ePv//9GGhjoKQGQCRLEA "05AB1E ‚Äì Try It Online") Explanation:
```
√Ü           Subtract all the elements from the first
 ¬∏¬´         Append to the original list
   !        Take the factorial of all the elements
    R.¬´√∑    Reduce by integer division
```
I can't seem to find better ways of performing step 2 or step 4.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 17 bytes
```
‚ä¢‚àò!√∑(√ó/‚àò!‚ä£,‚ä¢-1‚ä•‚ä£)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG9qQIACkHQLetQ2wdhEwdDIwvx/GpD9qGvRo44Zioe3axyerg9iPeparAMU1DV81LUUyNb8/9847VHvCgUjBQMuCMtQwZDL0BDKNFEw4TKBso24DE3BTFOgsDGQawnhmpmClRkbQdSZPurdAldqAuQYcxkaGBiAuRqGBkABQwNNHQ0LMMNAk8sYaq05lylEj5EFAA "APL (Dyalog Unicode) ‚Äì Try It Online")
Infix tacit function (Thanks to @Ad√°m for the 2 bytes it saves.)
---
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 19 bytes
```
{(!‚ç∫)√∑√ó/!(‚ç∫-+/‚çµ),‚çµ}
```
[Try it online!](https://tio.run/##JYw9CsJAEIX7OcWk28WEzOyPiRewDt4gIGsT0FYkrd2KjXgRRbDNTfYi6yQ2730z7/H601Dtz/1wPOR0e3Qdim536Xq3Dtm0TQ7CF1Wk@NXTZ3rWhRKsVnWKb12KjDnbgAYJxBgZmGd36MDNYIB9QC8PK7wRXvsltUZin@Lr33BCFpiIAiomuZh0qdoFSIOd5xvwUjXtDw "APL (Dyalog Unicode) ‚Äì Try It Online")
Infix Dfn. 
Both functions above compute the given formula.
[Answer]
# [Haskell](https://www.haskell.org/), ~~59~~ 58 bytes
```
f n=product[1..n]
n#k=foldl((.f).div)(f n)k`div`f(n-sum k)
```
[Try it online!](https://tio.run/##fZTLThxHFIb38xQNZAHSGNW5Vp0FG28dxYsskSWsDAjEeLAMRPbTk6@AxJ4saHpEd9e5/Zeq68/3t5fb7dPT1bI7@/rtbvP418O5nJ7uPq12R7dnV3fbzfb4@PTq5HRz8/fJMVEntxc8Xlwd797dP35Zbk@evi8X99d3j9vN@8uL5cdytnx9fPjz4dvvu@W35eZq@X529mN5uL7cLYcfP5weLpfb@8vl8I@7h@Xjh4ODg8PV6svnmx1pm7vVauGyo3NdL@3Tr2XtvyVZL7K3lC9LIs9rzr2f6RntJcRnhO6tir5mx9F5rH1t/1u3Prjba4EiKmfYfgsp84gWXUrMKrNH78mX1pu1of/2N53I3vjbq@pNZs2yTGkmNnoM18j2cv2c29bPf/sj5eD@GcYT4Nv6zfvN3375UarZhqWI98yWPqzGSOnWuqYOUx1SkOfdvCy8lWQov2ZdUqFmGP@pQ4my1mJQFLordBBuJsO7eHSD06gsOnWHB48ho1eY0KAV9NZwo8UzXandaJ2aolA/qjRJ4JNDHwX6IEqgtFsI7xEjqhoqa5RQl2sGlHq5O2JyVxexRE5lMuaA3hHaGqnByJbNJXu1ygZExh08RWT1dKNsQU0CcmhTOHJXgzveu@dwmVPyAl6h3FBLCxD06jFxWPmoAWNQ3FLJK9PpsISkGLTw9GQ4avWwwQQ8tvlGvejUhj5QVm/VlDEZNyiDPOgTqk5DiG7wEs11KsLbhAYuIqWiN1WFacAJ0glyiSeGb50higkiUN3FvYY0eGqzuzEwKMojcxSkk1eTTmwyRW34BhI6KJu4wii7B887OFCccgqmoj9mmCDhaXSECyeUmkThgXRaUCwN60HwlHLMbiAgNGaDOfdAYeiBSHUr/DhmWp/eC@qDW32kJdOUY2UKOc1bTA1oDebK0U3wgLLTCcKIjkx9DsZJQB6ETcAYBbEm4cU@QQ9nK0/iMBps9MSoSImDoFjpjEbgmK6covKm81hJLGnAa0wcwhxJCpERTAZVwefpCsDYtH6bj20Aii/SsWYMtiS6ktL7RFotZU7gqgZGnKg6m2AdzWn6hMG5pRRrus29x36sjhPnsKbTasaOHmg4hy4clvgWabEKHJigIs6evv7lej0I5zne908UIZ9jTtrq6R8 "Haskell ‚Äì Try It Online")
Thanks to [BMO](https://codegolf.stackexchange.com/users/48198/bmo) for saving 1 byte!
[Answer]
# Clojure, 70 bytes
```
#(let[a apply](a /(map(fn[x](a *(map inc(range x))))(conj %(a - %)))))
```
Creates an anonymous function taking all of the arguments as a single list, with `n` first.
30 characters are "wasted" just defining the damn factorial function. Oh well.
[Answer]
# [Perl¬†6](https://perl6.org), ~~¬†52¬†~~ 50 bytes
```
->\n,\k{[*](1..n)div[*] ([*] 1..$_ for |k,[-] n,|k)}
```
[Test it](https://tio.run/##fZTNblw3DIX38xR3EdR2ej2RSIoSbSRIF10UKNBN0Y1jFEE8LQw744F/0gZJnt35aAeeySYzd@wriSLPOTzSZnV96fd3N6vpgy/fHS/ef5x@end1tppe3h@@erOe31x8Onl@ul@Xy/XB2fkH3qf9/MPEs7@nf66up88X88nh6bSeP18cfLln/@vb1c3t9HK6PF@vbvYPlv9erzb7L/aO9l4cLN@/3RxNz5c3m8vz2/29o2nv4KSeLn/965ffjxeLRPEne48Xm8u36@nnx0RUneR4kaUeJw5fTa/P15u722n/2Xp@fXEwP1v9v1m9u12dTZ8W03R@c3i2Wm0uP05J5FvMcv32@vrqv3l6ip2/ZVlukOB48eX@txwdTTpPJzJP5XTxx93t48xisbNW56lu1/xprdbHRePZ2WveylOMPYTIdrnKdn9jsc02626A9sFTtikiwzzjdqrUUGuttF6jqoZ7b707M6UXLUN2IKg88PvBd5vWSs2koe61aNXR2zBpXh4/30PX@eG7A8oHz3dxDFKBMv/w@eFvJ/8IES9DvVbr7sVtaIzhtWvp4jJUZNRAQOtqoc1KVG/Cr2ivLqgzlP/kIUVoKW2QFMmjySBctQ7r1VpXZG3hQaVuKGFt1NGjaaVACRSOYUqJB8FculLaxaug/ogQZwNThoAk6IOoiqhdW2Xc2mgRhU5Li0pePhkQYmFm9JMneq3qdFRABg70HU1KYWsDsnqx6j1KeIEicAdvrXl0NyVtII1DckgRNDITRTvG3XxYTZQM4FtJN0RdGwx69JY8NGzEQDEkLi7sC5U0mSNSG5QwNwccuXrTAQJeS47I1zq5kQ@W0UsUASZwG2loD/1pIkZBhC7o0opJdoRRUoMXkTVaLyKC0pCrtK7SrmqO50sHRICgNbpu1SxGLehUsroCGBZhzX0EorMvUk5skk0t@AYROixLNUFRDhCuN3jQcdIJnIL6mCFJotPoNK4ZoeQkCg@4UYJkrlgPgbOVI6vBgNCWBRL3oMPIg5BiGvhx5Lae3mvkh7fYcHXQhGFlEhnFS8seUBrO4aNrxQPCYScIIxpt6gmMy4B9CJaEMQrNSsGDc0I/jMOcwmE01OiOUWklDkJioTI9gke6MpvKSPJmcSyp0CsgbhUczhYiWwMZUjWm0xWQ0bR@ydcyIMVM7VizDY4kfWVL78k0itdEYCIKR5wokkWwjnia3lEwj5RgTdM8e5zH6Dgxwaqk1ZQTPehhgg4c5viW1mIVNNBKF3F2@nrns70LH@7zvnOlVBJw09VtTMu7TcbOjZxNAxjG5bRK@Qo "Perl 6 ‚Äì Try It Online")
```
->\n,\k{[*](1..n)/[*] ([*] 1..$_ for |k,[-] n,|k)}
```
[Test it](https://tio.run/##fZTPT1w3EMfv@1e8Q1QgfSz2zHjsASVKDz1UqtRL1QtBVRS2FYIsKyBpoyR/O/kMROzmkt238GyPZ@b7w96sbq78/v3tavrgy7cni3cfp5/eXp@vphf3hy9fr@fXl59On5/t1@VyfXDE27Sffxg@@3v65/pm@nw5nx6eTev58@XBl3t2v7pb3d5NL6ari/Xqdv9g@e/NarN/tHe8d3SwfPdmczw9X95uri7u9veOp72D03q2/PWvX34/WSyyhz/Ze7LYXL1ZTz8/Jjq/@DDJySJLPU4cvpxeXaw37@@m/Wfr@dXlwfxs9f9m9fZudT59WkzTxe3h@Wq1ufo4JYxvMcv1m5ub6//m6Sl2/pZluYGAk8WX@99ydDzpPJ3KPJWzxR/v7x5nFoudtTpPdbvmT2u1Pi4az85e81aeYuwhRLbLVbb7G4tttll3A7QPnrJNERnmGbdTpYZaa6X1GlU13Hvr3ZkpvWgZstOCygO@H3y3aa3UTBrqXotWHb0Nk@bl8fN96zo/fHea8sHzXRyDZKDMP3x@@NvJP0LEy1Cv1bp7cRsaY3jtWrq4DBUZNSDQulposxLVm/Ar2qsL7AzlP3lIEVpKGySF8mgyCFetw3q11hVaW3hQqRtMWBt19GhaKVAChmOYUuKBMJeulHbxKrA/IsTZwJRBIAn6IKpCatdWGbc2WkRBaWlRycsnA0IszAw9eaLXqo6iQmf0Ab@jSSlsbbSsXqx6jxJegEi7g7fWPLqbkjagxgE5pAgcmYnCHeNuPqxmlwzAW0k3RF0bCHr0ljg0bMSAMSguLuwLlTSZQ1IblDA3pzly9aaDDngtOSJf6@SGPlBGL1GENmm3kQZ50KeJGAUhusBLKyapCKOEBi4ia7ReRASmAVeRriJXNcfzpdNE0EFrqG7VLEYt8FSyutIwKMKa@whIZ18kndgkRS34BhI6KEs1gVEOEK43cKA46QRMQX3MkCDhaXSEa0YoOYnCA26UIJkr1oPglHJkNRAQ2rJA9j1QGHogUkwDP47c1tN7jfzgFhuuTjdhWJlERvHSUgNKgzl8dK14QDjsBGFEQ6aejXEZsA/CEjBGQawkPDgn6GEc5iQOo8FGd4yKlDgIioXKaASOdGWKykjyZnEsqcArdNwqfThbiGyNzqCqMZ2uAIym9Uu@lgEoZmrHmm1wJNGVLb0n0iheswMTUTDiRJEsgnXE0/QOg3mkBGua5tnjPEbHidmsSlpNOdEDDbPpwGGOb5EWq8CBVlTE2enrnc/2Lny4z/vOlVJJwE1XtzEt7zYZOzdyikZjGJfTKuUr "Perl 6 ‚Äì Try It Online") (result is a Rational with denominator of 1)
## Expanded:
```
->     # pointy block lambda
  \n,
  \k
{
    [*]( 1 .. n )   # factorial of ÔΩ¢nÔΩ£
  /                 # divide (produces Rational)
    [*]             # reduce the following using &infix:¬´*¬ª
      (
          [*] 1..$_ # the factorial of
        for         # each of the following
          |k,       # the values of ÔΩ¢kÔΩ£ (slipped into list)
          [-] n,|k  # ÔΩ¢nÔΩ£ minus the values in ÔΩ¢kÔΩ£
      )
}
```
]