text:
Fibonacci-orial
Definition
Fibonacci sequence F(n), on the positive integers, are defined as such:
1. F(1) = 1
2. F(2) = 1
3. F(n) = F(n-1) + F(n-2), where n is an integer and n > 2

The Fibonacci-orial of a positive integer is the product of [F(1), F(2), ..., F(n)].
Task
Given positive integer n, find the Fibonacci-orial of n.
Specs
The fibonacci-orial of 100 must compute in under 5 seconds on a reasonable computer.
Testcases
n   Fibonacci-orial of n
1   1
2   1
3   2
4   6
5   30
6   240
7   3120
8   65520
9   2227680
10  122522400
11  10904493600
12  1570247078400
13  365867569267200
14  137932073613734400
15  84138564904377984000
16  83044763560621070208000
17  132622487406311849122176000
18  342696507457909818131702784000
19  1432814097681520949608649339904000
20  9692987370815489224102512784450560000
100 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

References

Obligatory OEIS A003266
OEIS A000045 - Fibonacci sequence

Related.

@Dennis 1. So it took half a second to import them and your program finished in half a second? 2. Yes. 3. Just let it overflow

Can F(100) return Infinity if our language cannot handle numbers that large?

@MayorMonty I would say no, but that would invalidate an existing answer.

The issues in the above comments could probably have been solved by asking for the Fibonacci-sum instead of the the Fibonacci-orial. Besides, there's some chance that Mathematica doesn't have a builtin for that :-P

@LuisMendo The sum of fibonacci is... you've guessed it, fibonacci. Well, minus one.

@LeakyNun Oh, I hadn't thought about that

@downvoter: can you tell me how I can make this challenge better?

@LeakyNun Currently the JavaScript answer only completes the test cases up to 15 because JavaScript cannot correctly compare (or manipulate) numbers beyond 2^53 - 1. This is most likely similar for a lot of the submissions here, because most languages don't support  numbers that big

What do you mean by "reasonable computer"?

-1 because this seems like several challenges tacked together (range, fibonacci of each, factorial) with no particularly interesting shortcuts.

Can this be 0 indexed?

@tfbninja sure, why not

Mathematica, 10 bytes
Fibonorial

Another Mathematica built-in soundly beaten by a golfing language without the built-in.

I… w-what… why, Mathematica?!

Forgot that function even existed!

@Lynn Rule 35: If it exists, there's a Mathematica function of it ;)

@BetaDecay I thought we had established that it's Rule 110.

No, Rule 110 is something very different. Though I'm sure Mathematica has a built-in for that, too.

@TimmyD took long enough for someone to get the reference. ;)

Jelly, 6 bytes
+Ð¡1ḊP

Input 100 finishes in 500 ms locally. Try it online!
How it works
+Ð¡1ḊP  Niladic link. No input.
        Since the link doesn't start with a nilad, the argument 0 is used.

   1    Yield 1.
+       Add the left and right argument.
 Ð¡     Read a number n from STDIN.
        Repeatedly call the dyadic link +, updating the right argument with
        the value of the left one, and the left one with the return value.
        Collect all values of the left argument into an array.
    Ḋ   Dequeue; discard the first Fibonacci number (0).
     P  Product; multiply the remaining ones.

So is +¡1 a non-built in nth fibonacci and +Ð¡1 is the first n Fibonacci numbers?

@cairdcoinheringaahing Pretty much.

I thought there was a built-in fibonacci function?

Brainfuck, 1198 1067 817 770 741 657 611 603
,[>++++++[-<-------->]<<[->++++++++++<]>>,]>+>+>>+>+<<<<<<[->>>[[-]
<[->+<]>>[-<+<+>>]<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->
[-]>>>>>>+>+<<<<<<<<[->+<]]]]]]]]]]]+>>>>>>>>]<<<<<<<<[->[-<+<<+>>>
]<[->+<]>>>[<<<<<[->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>]<<<<<<<<[->>>[-<
<<<<<<<+>>>>[->+>>+<<<]>[-<+>]>>>]<<[->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
]>>>[-]>>>>>[[-]>[->+<]>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<
+>[->>>>>>+>+<<<<<<<<[-]]]]]]]]]]>]<<[<]+>>>>>>>>]<<<<<<<<[<<<<<<<<
]>>>>>[>>>>>>>>]+<<<<<<<<]>>>>>>>>>>>[<[-]>>[-<<+>>]>>>>>>>]<<<<<<<
<[<<<<<<<<]>>]>>>>>>[>>>>>>>>]<<<<<<<<[+++++[-<++++++++>]<.<<<<<<<]

Uncompressed, with comments:
# parse input (max 255)
,[>++++++[-<-------->]<<[->++++++++++<]>>,]
>+>+>>+>+<<<<<<
[->>>
  # compute next fibonacci number
  [[-]<
    [->+<]>>
    [-<+<+>>]<
    # perform carries
    [->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<[->+<
      [->[-]>>>>>>+>+<<<<<<<<[->+<]]
    ]]]]]]]]]+>>>>>>>>
  ]<<<<<<<<
  # multiplication
  [->
    # extract next digit of F_n (most significant first)
    [-<+<<+>>>]<
    [->+<]>>>
    # move back to the end
    [<<<<<
      [->>>>>>>>+<<<<<<<<]>>>>>>>>>>>>>
    ]<<<<<<<<
    # digit wise multiplication (shifting current digit)
    [->>>
      [-<<<<<<<<+>>>>
        [->+>>+<<<]>
        [-<+>]>>>
      ]<<
      # shift previous total over one gap (in effect multiplying by 10)
      [->>>>>>>+>+<<<<<<<<]<+<<<<<<<<
    ]>>>[-]>>>>>
    # add product to total
    [[-]>
      [->+<]>
      # perform carries
      [-<+>
        [-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>[-<+>
          [->>>>>>+>+<<<<<<<<[-]]
        ]]]]]]]]>
      ]<<[<]+>>>>>>>>
    ]<<<<<<<<
    [<<<<<<<<]>>>>>
    [>>>>>>>>]+<<<<<<<<
  ]>>>>>>>>>>>
  # overwrite previous product
  [<[-]>>
    [-<<+>>]>>>>>>>
  ]<<<<<<<<
  [<<<<<<<<]>>
]>>>>>>
# output product
[>>>>>>>>]<<<<<<<<
[+++++
  [-<++++++++>]<.<<<<<<<
]

Try it online!
Runtime for n = 100 is less than 1 second with the online interpreter (about 0.2s locally using my own interpreter). Maximum input is 255, but would require the interpreter to support ~54000 cells (the online interpreter seems to wrap on  64k).

Change Log
Saved around 130 bytes with better extraction of the current digit to multiply through by, and by merging add and carry into a single pass. It also seems to be a bit faster.
Saved another 250 bytes. I managed to reduce my multiplication scratch pad by two cells, which saves bytes just about everywhere by not having to shift so far between digits. I also dropped the carry after multiplying through by a digit, and instead perform a full carry whilst adding to the running total.
Chopped another 50, again with better extraction of the current digit to multiply through by, simply by not moving it forward the first iteration, and working from where it is. A few micro-optimization further down account for around ~10 bytes.
30 more gone. Marking digits that have already been taken with a 0 rather than a 1 makes them easier to locate. It also makes the check if the multiplication loop has finished somewhat simpler.
I reduced the scratch pad by another cell, for 80 more bytes. I did this by merging the marker for the previous product and the current running total, which reduces the shifts between gaps, and makes bookkeeping a bit easier.
Saved another 50, by eliminating yet another cell, reusing the marker for fibonacci digits to mark the last digit taken as well. I was also able to merge the loop to shift the previous totals with the digit-wise multiplication loop.
Saved 8 bytes on input parsing. Oops.

Actually, 4 bytes
Runs the input 100 within 0.2 seconds. Code:
R♂Fπ

Explanation:
R     # Get the range [1, ..., input].
 ♂F   # Map over the array with the fibonacci command.
   π  # Take the product.

Uses the CP-437 encoding. Try it online!.

This is the right tool for the job :) Thanks to some improvements to the Fibonacci function that Leaky Nun made a while back, the 100 test case runs in 0.1 seconds on TIO.

Python, 45 Bytes
a=b=o=1
exec"o*=a;a,b=b,a+b;"*input()
print o

Input is taken from stdin. Output for n = 100 finishes too quickly to accurately time. n = 1000 takes approximately 1s.
Sample Usage
$ echo 10 | python fib-orial.py
122522400

$ echo 100 | python fib-orial.py
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

Haskell 41 29 Bytes
1+11 bytes saved by @Laikoni's remarks.
f=1:scanl(+)1f
(scanl(*)1f!!)

1,f and !! are separate tokens.
The first lines defines the fibonacci sequence, the second is a function that computes the sequence of fibonacci-orials and returns the n-th  for a given n. It starts printing digits almost immediately even for n=1000.

You can get rid of the space (scanl(*)1f!!).

And there is a shorter fibonacci generator here: f=1:scanl(+)1f

@Laikoni That's amazing, thanks!

first line makes sense only as part of a source file. second only in interpreter (and then, external parentheses are superfluous).

@WillNess That's why I wrote: First line defines, second is ... Doing so agrees with haskell entries from other users. Without the outer parentheses it would only be a code fragment (that could be followed by a value), with them it really is a function that can for example replace the dots in the expression map ... [1,50,100]

I'm not sure if that's allowed. Isn't it supposed to be full program? Again, not sure.

@WillNess I think I am not only justified by what other users do, but also by http://meta.codegolf.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet and http://meta.codegolf.stackexchange.com/questions/9031/unnamed-functions-in-code-golf?noredirect=1&lq=1 (but there is a lot more and I haven't read all)

Can anyone explain why we actually need the parenthesis around around the expression in the second line?

@flawr Would you accept 42+ as a function that adds 42? You shouldn't, because it is just an unfinished expression. But in Haskell we can add parentheses and get the section (42+), a way to write the function \n->42+n. Here it is the same, only with !! (the binary infix operator for indexing) instead of + and a more complicated first operand.

Ah now I see, thank you very much!

Python 2, 39 bytes
f=lambda n,a=1,b=1:n<1or a*f(n-1,b,a+b)

Test it on Ideone.

You may want to specify that it returns True in some cases.

This would only return True for input 0, which isn't positive.

J, 17 16 bytes
1 byte is golfed with even better solution by miles.
[:*/+/@(!|.)\@i.

The idea is the same as the original but instead of forming the matrix to operate on minor diagonals we form the diagonals on the fly.

Original
To get the first n fibonomials:
*/\(#{.+//.)!/~i.

Reading right to left...
Create the array of consecutive integers (i.) up to specified one, from that array create the table (/~) of binomial coefficients (!) calculated from every pair in the array, this table is Pascal's triangle top of whlocated at the end of the first row and all elements under the main diagonal are 0, thankfully to implementation of !. If you sum (+/) all minor diagonals (/.), you get Fibonacci numbers, but you need to take ({.) as much of first elements from the resulting array as the length (#) of the table itself. Then the product (*/) applied to consecutive prefixes (\) of the array results into desired sequence of fibonorials. If you wish you can take only the last one using 2 more bytes ({:) but I thought that displaying all of them is not a sin :).
NB. the previous code block is not a J function.
   {:*/\(#{.+//.)!/~i. 10
122522400

For big numbers in J you use x at the end:
   {:*/\(#{.+//.)!/~i. 100x
3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225...

The program runs on avarage 0.11s.
   100 timex '{:*/\(#{.+//.)!/~i.100x'
0.112124

An alternative that is a function is [:*/+/@(!|.)\@i. using 16 bytes. It forms that same binomial coefficients along the table you generate using !/~ except that it forms that by taking prefixes of i..

R, 99 96 78 76 66 bytes
This answer is uses Binet's Formula, as well as the prod(x)function. Since R doesn't have a build-in Phi value, I defined it myself :
p=(1+sqrt(5))/2;x=1;for(n in 1:scan())x=x*(p^n-(-1/p)^n)/sqrt(5);x

It works under 5 seconds, but R tends to give Inf as an answer for those big numbers...
Ungolfed :
r=sqrt(5)
p=(1+r)/2
x=1
for(n in 1:scan())
    x=x*(p^n-(-1/p)^n)/r
x

-2 bytes thanks to @Cyoce !
Oh, do I love this site ! -10 bytes thanks to @user5957401

Might be able to save a bit by storing sqrt(5) to a variable

since you only use N once, you can just call scan inside the 1:N bit. i.e. for(n in 1:scan()).
You can also save a few characters by just using * instead of the prod() function in your for loop.
Your for loop is only one line, so you don't need the curly braces either.

Nice idea to use Binet's formula. In your spirit but only 53 bytes is function(n,N=1:n,p=5^.5)prod(((1+p)^N-(1-p)^N)/2^N/p)

Jelly, 8 bytes
RḶUc$S€P

My first submission in Jelly. It's not as short as @Dennis' answer, but its only 2 bytes longer with a different method.
Locally, it requires about 400ms compared to 380ms with @Dennis' version for n = 100.
Try it online!
Explanation
RḶUc$S€P  Input: n
R         Generate the range [1, 2, ..., n]
          For each value x in that range
 Ḷ          Create another range [0, 1, ..., x-1]
  U         Reverse that list
   c        Compute the binomial coefficients between each pair of values
    $       Bind the last two links (Uc) as a monad
     S€   Sum each list of binomial coefficients
          This will give the first n Fibonacci numbers
       P  Take the product of those to compute the nth Fibonacci-orial

Pyth, 13 bytes
u*Gs=[sZhZ)Q1

Demonstration
This employs a clever, non-typesafe trick. Five of the characters (u*G ... Q1) say that the output is the product of the input many numbers. The rest of the code generates the numbers.
=[sZhZ) updates the variable Z to the list [s(Z), h(Z)]. Then s sums that list, to be multiplied.
Z is initially 0. s, on ints, is the identity function. h, on its, is the + 1 function. So on the first iteration, Z becomes [0, 1]. s on lists is the sum function, as mentioned above. h is the head function. So the second iteration is [1, 0].
Here's a list:
Iter  Z          Sum
0     0          Not used
1     [0, 1]     1
2     [1, 0]     1
3     [1, 1]     2
4     [2, 1]     3
5     [3, 2]     5

These sums are multiplied up to give the result.

Mathematica 25 24 bytes
With thanks to Martin Ender.
1##&@@Fibonacci@Range@#&

1##&@@Fibonacci@Range@#&@100

Timing: 63 microseconds.
{0.000063,
3371601853146468125386964065447576689828006172937411310662486977801540
6711385898686165008341900290675836651822917015531720110825745874313823
1009903039430687777564739516714333248356092511296002464445971530050748
1235056111434293619038347456390454209587101225261757371666449068625033
9995735521655245297254676280601708866020010771376138030271586483293355
0772869860576999281875676563330531852996518618404399969665040724619325
7877568825245646129366994079739720698147440310773871269639752334356493
6789134243905645353892122400388956268116279491329780860702550826683922
9003714114129148483959669418215206272639036409444764264391237153249138
8089634845995941928089653751672688740718152064107169357399466473375804
9722605947689699525073466941890502338235963164675705844341280523988912
2373033501909297493561702963891935828612435071136036127915741683742890
4150054292406756317837582840596331363581207781793070936765786629772999
8328572573496960944166162599743042087569978353607028409125185326833249
36435856348020736000000000000000000000000}

Alternately, with same byte count: 1##&@@Fibonacci~Array~#&

R, 82, 53, 49 bytes (48 bytes w/ different input style)
b=d=1;a=0;for(i in 1:scan()){d=d*b;b=a+b;a=b-a};d

If we can just precede the code with the input number, we get the 48 byte
->n;b=d=1;a=0;for(i in 1:n){d=d*b;b=a+b;a=b-a};d

EDIT: New code. Original is below:
a=function(n)ifelse(n<3,1,{v=c(1,1,3:n);for(i in 3:n)v[i]=v[i-1]+v[i-2];prod(v)})

Won't return anything other than Inf for a(100) though. And it won't work for anything but non-negative integers.
Ungolfed:
a=function(n){
   if(n<3) return(1)
   v=c(1,1,3:n)
   for(i in 3:n)
       v[i]=v[i-1]+v[i-2]
   prod(v)
}

PARI/GP, 29 bytes
f=n->prod(i=1,n,fibonacci(i))

Or alternatively:
f=n->prod(i=a=!b=0,n,b=a+a=b)

Brachylog, 31 bytes
,[1:0]:?:{hH,?bh:H+g:?c.}irbb*.

Try it online!

APL (Dyalog Unicode), 18 bytes
×/(+.!∘⌽⍨∘⍳¨1+∘⍳⊢)

Explanation:
×/(+.!∘⌽⍨∘⍳¨1+∘⍳⊢)
            1+∘⍳⊢   ⍝ generate numbers 2-(⍵+1)
           ¨        ⍝ ... map to each
   +.!∘⌽⍨∘⍳         ⍝ n-th fibonacci number
×/                  ⍝ product of all

Fibonacci formula explanation:
+.!∘⌽⍨∘⍳
       ⍳    ⍝ numbers 1 to ⍵
     ⍨      ⍝ apply to both sides of +.!∘⌽
    ⌽       ⍝ reverse the ⍵ vector.
+.!         ⍝ inner product: sum and binomial

Try it online!

This template may be helpful for future programs.

@Razetime I've seen it, but it didn't work for me - I accidentally put my footer code in the footer. I'll use it next time I need to do something

Since you're only using the argument once (⊢) and you hand two consecutive atops, a full program would save 3 bytes: ×/+.!∘⌽⍨∘⍳¨1+⍳⎕

Forth, 55 bytes
Uses an iterative approach, built upon my Fibonacci answer in Forth. The results overflow arithmetically for n > 10. The answer is case-insensitive.
: f >r 1 1 r@ 0 DO 2dup + LOOP 2drop 1 r> 0 DO * LOOP ;

Try it online

Javascript (ES6), 51 39 bytes
Recursive implementation (39 bytes)
f=(n,a=p=i=b=1)=>++i<n?f(n,b,p*=b+=a):p

Original implementation (51 bytes)
n=>{for(i=a=b=p=1;++i<n;){c=a;a=b;p*=b+=c}return p}

Note: Starts rounding errors for the Fibonacci-orial of 16, 100 is just Infinity, runs in what appears to be <1 second.

I made an alternate 53-byte version n=>[...Array(n)].reduce(p=>(c=a,a=b,p*=b+=c),a=1,b=0) only to discover that you'd counted the f= which isn't required saving you 2 bytes.

Fair point. My rationale was so it was callable and reusable rather than just callable.

Sure, but if someone does want to reuse it then they still have the option of naming it.

@Neil Well now I went and re-implemented it and now the f= is mandatory or else it can't actually execute. :D

Well at least you fixed the byte count for the original implementation.

f=(n,a=p=b=1)=>n>2?f(n-1,b,p*=b+=a):p for 37 bytes ;)

Ruby, 39 bytes
->n{f=i=b=1;n.times{f,i,b=i,f+i,b*f};b}

36: ->n{f=i=b=1;n.times{b*=f;i=f+f=i};b}

DC (GNU or OpenBSD flavour), 36 bytes
File A003266-v2.dc:
0sA1sB1?[1-d0<LrlBdlA+sBdsA*r]dsLxrp

(no trailing newline)
...now the result is held on the stack instead of using a named register (is Y in version 1). The r command is not available in the original dc (see RosettaCode's Dc page).
Run:
$ time dc -f A003266-v2.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.005s
user    0m0.004s
sys     0m0.000s

Trying to explain:
tos is the contents of the top of the stack without removing it.
nos is the element below tos.
0 sA # push(0) ; A=pop()
1 sB # push(1) ; B=pop()
1    # push(1)
     # this stack position will incrementally hold the product
?    # push( get user input and evaluate it )
[    # start string
 1-  # push(pop()-1)
 d   # push(tos)
 0   # push(0)
 <L  # if pop() < pop() then evaluate contents of register L
 r   # exchange tos and nos
     # now nos is the loop counter
     # and tos is the bucket for the product of the fibonacci numbers
 lB  # push(B)
 d   # push(tos)
 lA  # push(A)
 +   # push(pop()+pop())
     # now tos is A+B, nos still is B
 sB  # B=pop()
     # completes B=A+B
 d   # push(tos)
 sA  # A=pop()
     # completes B=A
     # tos (duplicated new A from above) is the next fibonacci number
 *   # push(nos*tos)
     # tos now is the product of all fibonacci numbers calculated so far
 r   # exchange tos and nos
     # now tos is the loop counter, nos is the product bucket
]    # end string and push it
d    # push(tos)
sL   # L=pop()
x    # evaluate(pop())
r    # exchange tos and nos
     # nos now is the former loop counter
     # tos now is the complete product. \o/
p    # print(tos)
     # this does not pop() but who cares? :-P

DC, 41 bytes
...straight forward, no tricks:
File A003266-v1.dc:
0sA1sB1sY?[1-d0<LlBdlA+sBdsAlY*sY]dsLxlYp

(no trailing newline)
Run:
$ for i in $(seq 4) ; do dc -f A003266-v1.dc <<< $i ; done
1
1
2
6
$ time dc -f A003266-v1.dc <<< 100
337160185314646812538696406544757668982800617293741131066248697780154\
067113858986861650083419002906758366518229170155317201108257458743138\
231009903039430687777564739516714333248356092511296002464445971530050\
748123505611143429361903834745639045420958710122526175737166644906862\
503399957355216552452972546762806017088660200107713761380302715864832\
933550772869860576999281875676563330531852996518618404399969665040724\
619325787756882524564612936699407973972069814744031077387126963975233\
435649367891342439056453538921224003889562681162794913297808607025508\
266839229003714114129148483959669418215206272639036409444764264391237\
153249138808963484599594192808965375167268874071815206410716935739946\
647337580497226059476896995250734669418905023382359631646757058443412\
805239889122373033501909297493561702963891935828612435071136036127915\
741683742890415005429240675631783758284059633136358120778179307093676\
578662977299983285725734969609441661625997430420875699783536070284091\
2518532683324936435856348020736000000000000000000000000

real    0m0.006s
user    0m0.004s
sys     0m0.004s

Explanation please?

Any link to online interpreter or official website?

*sigh!* ... writing dc code definitely is easier than explaining it...

Yeah, we really need an IDE with some kind of crazy multiple-stack visualisation gadget... that would be sweet.

I have several ideas what to add as new commands, but the idea with the highest impact seems to be: Add a "change default stack" command. ;-)

...or swap default stack with a named register. That would make more knots in users' brains but would not need the default stack to have a name... ]:-)

Yes, that would definitely be handy! I'd also like to clear a single item, rotate items that aren't at the top of the stack, and maybe shift the top n items to another stack at once. For now, though, I still don't know how to compile dc from source. :/

I only can give unixish answers: Gab a not so bloated version of Dc. Put an empty sigset.h in the same directory as the sources and compile by gcc -I. -DSHELL='"/bin/sh"' dc.c -s -o dc. (Tested on Debian-8.5)

C# 110 109 107 103 101 94 Bytes
using i=System.Numerics.BigInteger;i f(i n){i a=0,b=1,x=1;for(;n-->0;)x*=a=(b+=a)-a;return x;}

Explanation
//Aliasing BigInteger saves a few bytes
using i=System.Numerics.BigInteger;

//Since BigInteger has an implicit from int we can also change the input
//and save two more bytes.
i f(i n)
{
    //using an alternative iterative algorithm (link to source below) to cut out the temp variable
    //b is next iteration, a is current iteration, and x is the running product
    i a = 0, b = 1, x = 1;

    //post decrement n down to zero instead of creating a loop variable
    for (; n-- > 0;)

        //The bracket portion sets the next iteration
        //get the current iteration and update our running product
        x *= a = (b += a) - a;

    return x;
}

Iterative Fib algorithm

Given this performed so much better than I had expected I wanted to find the max N that would return in under 5 seconds, I came out with 1540 which gives a number that is 247441 digits long.

Impressive. How long does 1541 take to calculate, out of curiosity?

@Pandacoder So with the recent change to the algorithm it has gotten significantly faster. 1541 in 755 ms so i'm going to find the new sub 5 max now.

@Pandacoder so the run time is varying by a fair bit ~100ms but 2565 seems to average about 5 seconds

How long is the number for that?

@Pandacoder Came out to 686861 digits.

Java, 165 bytes
Golfed:
BigInteger f(int n){BigInteger[]a={BigInteger.ZERO,BigInteger.ONE,BigInteger.ONE};for(int i=0;i<n;){a[++i%2]=a[0].add(a[1]);a[2]=a[2].multiply(a[i%2]);}return a[2];}

This is yet another case where BigInteger being required due to large numbers. However, I was able to keep the text BigInteger to a minimum, keeping the size down. I also compared with static imports, and it made the total length longer.
This program works by tracking three numbers in an array. The first two are the previous two Fibonacci numbers. The third is the accumulated value. The loop starts out by calculating the next value and storing it in alternating (0, 1, 0, 1, ...) array indices. This avoids needing to shift values with costly (in terms of source size) assignment operations. Then grab that new value and multiply it into the accumulator.
By avoiding temporary objects and limiting the loop to two assignment operators, I was able to squeeze out quite a few bytes.
Ungolfed:
import java.math.BigInteger;

public class Fibonacci_orial {

  public static void main(String[] args) {
    // @formatter:off
    String[][] testData = new String[][] {
      { "1", "1" },
      { "2", "1" },
      { "3", "2" },
      { "4", "6" },
      { "5", "30" },
      { "6", "240" },
      { "7", "3120" },
      { "8", "65520" },
      { "9", "2227680" },
      { "10", "122522400" },
      { "11", "10904493600" },
      { "12", "1570247078400" },
      { "13", "365867569267200" },
      { "14", "137932073613734400" },
      { "15", "84138564904377984000" },
      { "16", "83044763560621070208000" },
      { "17", "132622487406311849122176000" },
      { "18", "342696507457909818131702784000" },
      { "19", "1432814097681520949608649339904000" },
      { "20", "9692987370815489224102512784450560000" },
      { "100", "3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000" }
    };
    // @formatter:on

    for (String[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new Fibonacci_orial().f(Integer.parseInt(data[0])));
      System.out.println();
    }
  }

  // Begin golf
  BigInteger f(int n) {
    BigInteger[] a = { BigInteger.ZERO, BigInteger.ONE, BigInteger.ONE };
    for (int i = 0; i < n;) {
      a[++i % 2] = a[0].add(a[1]);
      a[2] = a[2].multiply(a[i % 2]);
    }
    return a[2];
  }
  // End golf

}

Program output:
Input: 1
Expected: 1
Actual:   1

Input: 2
Expected: 1
Actual:   1

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 6
Actual:   6

Input: 5
Expected: 30
Actual:   30

Input: 6
Expected: 240
Actual:   240

Input: 7
Expected: 3120
Actual:   3120

Input: 8
Expected: 65520
Actual:   65520

Input: 9
Expected: 2227680
Actual:   2227680

Input: 10
Expected: 122522400
Actual:   122522400

Input: 11
Expected: 10904493600
Actual:   10904493600

Input: 12
Expected: 1570247078400
Actual:   1570247078400

Input: 13
Expected: 365867569267200
Actual:   365867569267200

Input: 14
Expected: 137932073613734400
Actual:   137932073613734400

Input: 15
Expected: 84138564904377984000
Actual:   84138564904377984000

Input: 16
Expected: 83044763560621070208000
Actual:   83044763560621070208000

Input: 17
Expected: 132622487406311849122176000
Actual:   132622487406311849122176000

Input: 18
Expected: 342696507457909818131702784000
Actual:   342696507457909818131702784000

Input: 19
Expected: 1432814097681520949608649339904000
Actual:   1432814097681520949608649339904000

Input: 20
Expected: 9692987370815489224102512784450560000
Actual:   9692987370815489224102512784450560000

Input: 100
Expected: 3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000
Actual:   3371601853146468125386964065447576689828006172937411310662486977801540671138589868616500834190029067583665182291701553172011082574587431382310099030394306877775647395167143332483560925112960024644459715300507481235056111434293619038347456390454209587101225261757371666449068625033999573552165524529725467628060170886602001077137613803027158648329335507728698605769992818756765633305318529965186184043999696650407246193257877568825245646129366994079739720698147440310773871269639752334356493678913424390564535389212240038895626811627949132978086070255082668392290037141141291484839596694182152062726390364094447642643912371532491388089634845995941928089653751672688740718152064107169357399466473375804972260594768969952507346694189050233823596316467570584434128052398891223730335019092974935617029638919358286124350711360361279157416837428904150054292406756317837582840596331363581207781793070936765786629772999832857257349696094416616259974304208756997835360702840912518532683324936435856348020736000000000000000000000000

05AB1E, 6 4 bytes
LÅfP

Try it online!
-1 from Robbie0630, -1 more from an improvement on his suggestion.

@robbie0630 LÅfP for 4, haven't looked here in a long time ;), you have to actually be careful with € it doesn't work on 2-byte commands. Also, with L, many things vectorize automatically (even list commands) so you don't need an iterator :).

Beat me to it :P

Perl 6, 23 bytes
{[*] (1,&[+]...*)[^$_]}

Try it online!

1, &[+] ... * is the infinite Fibonacci sequence.
[^$_] takes the first $_ elements of the sequence, where $_ is the argument to the function.
[*] reduces that subsequence with multiplication.

Brain-Flak, 54 bytes
([{}]<(())>){(({})()<{({}()<([({})]({}{}))>)}{}{}>)}{}

Try it online!
Multiplication in Brain-Flak takes a long time for large inputs.  Just multiplying F100 by F99 with a generic multiplication algorithm would take billions of years.
Fortunately, there's a faster way.  A generalized Fibonacci sequence starting with (k, 0) will generate the same terms as the usual sequence, multiplied by k.  Using this observation, Brain-Flak can multiply by a Fibonacci number just as easily as it can generate Fibonacci numbers.
If the stack consists of -n followed by two numbers, {({}()<([({})]({}{}))>)}{}{} will computen iterations of the generalized Fibonacci sequence and discard all by the last.  The rest of the program just sets up the initial 1 and loops through this for all numbers in the range n...1.
Here's the same algorithm in the other languages provided by this interpreter:
Brain-Flak Classic, 52 bytes
({}<(())>){(({})[]<{({}[]<(({}<>)<>{}<>)>)}{}{}>)}{}

Try it online!
Brain-Flueue, 58 bytes
<>(<(())>)<>{(({}<>)<{({}({}))({}[()])}{}>[()]<>)}<>({}){}

Try it online!
Mini-Flak, 62 bytes
([{}()](())){(({})()({({}()([({})]({}{}))[({})])}{}{})[{}])}{}

Try it online!

tinylisp, 83 81 bytes
(load library
(d F(q((N)(i(l N 3)1(a(F(s N 1))(F(s N 2
(d P(q((N)(product(map F(0to N

Try it online!
-2 bytes thanks to DLosc for reminding me to remove parentheses.
tinylisp, 108 bytes
(d F(q((N)(i(l N 3)1(a(F(s N 1))(F(s N 2
(d M(q((A B)(i A(a B(M(s A 1)B))0
(d P(q((N)(i N(M(F N)(P(s N 1)))1

Try it online!
Exceeds the maximum recursion depth around N=14.

@DLosc augh! that's what I get for copy-pasting the recursive call.

Ruby, 35 bytes
A Ruby fork of Dennis's Python answer. Golfing suggestions welcome.
f=->n,a=1,b=1{n<1?1:a*f[n-1,b,a+b]}

Try it online!
Ungolfed:
def f(n)
  a=b=z=1
  (1..n).each do |i|
     z*=a
     a,b=b,a+b
  end
  return z
end

n<1?1:a*f... is n<1||a*f...?

@StanStrum In Ruby, true can't be coerced into Integer.

Clojure, 70 bytes
Clojure isn't really a good language for code golf. Oh well.
Try it at http://tryclj.com.
(last(nth(iterate(fn[[a b r]][b(+ a b)(* r(+ a b))])[0N 1 1])(dec n)))

dc, 38 40 30 28 bytes
?si1d[sadlarla+zli>b]sbzli>b[*z1<*]ds*xf
si1d[sadlarla+zli>b*]sbzli>b

Expanded:
si     # Take input from top of stack and store it in register `i'
1d     # Push 1 on stack and duplicate
[      # Open macro definition
 sa    #  Store most recent term of Fibonacci sequence in register `a'
 d     #  Duplicate second most recent term
 la    #  Push most recent term onto stack
 r     #  Rotate top two items on stack
 la    #  Push most recent term onto stack (again)
       #  At this point, we've essentially duplicated the top two terms of the stack
       #    without altering the order of the terms
 +     #  Add top two terms of stack (generate next Fibonacci number)
 zli>b #  Take stack depth and load input (target number of terms); if we don't have
       #  enough terms yet, execute `b'
 *     #  Once we've generated all the terms (factors, really), we'll multiply
       #    them, one * for every time we iterated to generate a term
]sb    # Store macro in register `b'
zli>b  # Look familiar? This way, we change the "do-while" (`dsbx') to just "while"
       # Leave result on top of stack

z as implicit loop counter in zli!= is nice!!! And I like your idea to collect all factors on the stack and multiply them in a loop... ;-) ...but it hangs on input 1 and 2 here on GNU dc... :-(

@yeti Thanks :D And thanks for pointing out the bug; I hadn't noticed.

Mathematica - 32 26 bytes
Fibonacci@i~Product~{i,#}&

@MartinEnder chopped 6 bytes!

GAP 28 Bytes
Didn't know before today that GAP has a Fibonacci builtin.
n->Product([1..n],Fibonacci)

Can you link to GAP? No idea what it is.

Oh sure (but I'm not the first one to use it here...)

Ruby, 85 Bytes
g =->x{(1..x).to_a.collect{|y|(0..y).inject([1,0]){|(a,b),_|[b, a+b]}[0]}.inject(:*)}

Turned out fine, but there's probably a shorter solution.
Fast Fibonnaci calculation taken from here: link
Test it here

Julia, 36 bytes
!x=[([1 1;1 0]^n)[2]for n=1:x]|>prod

JavaScript (ES6), 46 bytes
f=(n,a=1,b=1,c=i=1)=>n==i?c:f(n,b,a+b,c*b,++i)

Uses recursion and accumulator variables. Rounding errors start at f(16).

Swift, 68 Bytes
func f(n:Int,_ a:Int=1,_ b:Int=1)->Int{return n<1 ?1:a*f(n-1,b,a+b)}

ForceLang, 140 bytes
def s set
s a 0
s b s p 1
s k io.readnum()
if k=1
goto b
label a
s c a+b
s a b
s b c
s p p.mult c
s k k+-1
if k+-1
goto a
label b
io.write p

Racket 130 bytes
(define(fb n)(cond[(or(= n 1)(= n 2))1][(+(fb(- n 1))(fb(- n 2)))]))
(define(fo n)(for/product((i(range 1(+ 1 n))))(fb i)))(fo n))

Ungolfed:
(define (f n)
  (define (fibonacci n)
    (cond
      [(or (= n 1)(= n 2)) 1]
      [else (+ (fibonacci (- n 1)) (fibonacci(- n 2)))] ))
  (define (f_orial n)
    (for/product ((i (range 1 (add1 n))))
      (fibonacci i)))
  (f_orial n))

Testing:
(f 1)
(f 2)
(f 3)
(f 4)
(f 5)
(f 6)
(f 7)
(f 8)
(f 9)
(f 10)
(f 11)
(f 12)
(f 20)
(f 30)

Output:
1
1
2
6
30
240
3120
65520
2227680
122522400
10904493600
1570247078400
9692987370815489224102512784450560000
607373569868916007005878071331449502263924414704952629297115029592606043656028160000000

cQuents, 16 15 bytes
=1:Zb$
=1,1:Z+Y

Try it online!
Explanation
=1:       Sequence with first term = 1
   Zb$    Each term equals the previous times the next line at the current index

=1,1:     Sequence with the first two terms = 1
     Z+Y  Each term equals the previous two terms added together

Pyt, 5 bytes
←ř⁻ḞΠ

Input is from stdin. Approximately instantaneous for n=100. Takes less than a second for n=1000.
Explanation:
←            Get input
 ř           Get [1,2,...,input]
  ⁻          Decrement all elements by 1
   Ḟ         Get Fibonacci numbers
    Π        Product

Try it online!

Husk, 4 bytes
Π↑İf

Try it online!
Explanation
Π↑İf  -- input is an integer N, for example 5
  İf  -- fibonacci numbers: [1,1,2,3,5,8,13,21,34…]
 ↑    -- take N: [1,1,2,3,5]
Π     -- product: 30

Fortran 95, 118 bytes
This version explicitly declares P as an integer, thus the limit is given by the size of the integer (4 bytes by default).
program o
integer,parameter::n=20
integer F(n),P
P=1
F(:2)=1
do i=3,n
F(i)=F(i-1)+F(i-2)
P=P*F(i)
enddo
print*,P
end

If I extend the size of the integer to 16 bytes, the byte count of the code increases by 3: integer*16 F(n),P.
One can also omit P from the declaration and use it as a 4 byte floating point, then the byte count is reduced by 2.

Pyt, 3 bytes
Zero indexed
Thanks to mudkip201 for catching my mistake
řḞΠ

Try it online!

         implicit input
ř        range from input to one
 Ḟ       fibonacci over array
  Π      product
         implicit output

I think you meant Π, not Ʃ

@mudkip201 good catch

Whispers v3, 43 bytes
> Input
> fₙ
>> 2ᶠ1
>> ∏3
>> Output 4

Try it repl.it!
Needs to be run with
python3 whispers\ v3.py fibonacciorial.wisp < input.txt 2> /dev/null

Finishes well within 5 seconds on repl.it.

I think it should be ∏ rather than ∑?

@Leo aaaaa missed that completely

Setanta, 65 62 bytes
gniomh(n){a:=0b:=1x:=1le i idir(0,n){b+=a a=b-a x*=a}toradh x}

Unfortunately isn't exact because this language doesn't have bigints.
Try it here!

Tcl, 110 bytes
set a 0
set b [incr x]
time {set c [expr $a+$b]
set a $b
set x [expr $x*[set b $c]]} [expr {*}$argv-1]
puts $x

Try it online!
Was able to take off 9 bytes thanks to sergiol!

I golfed your solution: https://tio.run/##K0nO@f@/OLVEIVHBgAtEJylEZ@YlFylUxHKVZOamKlSDBJMVolMrCooUVBK1VZJiuSDqVZLAjAqYXIVWNMQAleTY2FqoaLVWrUpiUXqZrmEsV0FpSTFQ2X9DA4P/IAIA

Tcl, 115 bytes
proc F x {expr $x>1?\[F $x-1]+\[F $x-2]:$x}
proc P x {incr p
while {[incr i]<=$x} {set p [expr $p*[F $i]]}
expr $p}

Try it online!

Vyxal, 7 bytes
ƛÞF$i;Π

Try it Online!
Vyxal r, 6 bytes
ƛÞFi;Π

Try it Online!
        # implicit input
ƛ    ;  # Lambda map (1...input inclusive)
 ÞF     # All fibbonacci numbers
   $    # Swap stack
    i   # Item
      Π # Reduce by product
        # Implicit output

With r, all functions take arguments in reverse, so $ is not needed.

Vyxal, 4 bytes
ÞFẎΠ

Try it Online!
Come on Vyxal, you can do better.
ÞFẎΠ # Takes a number input
ÞF   # Infinite Fibonacci numbers
  Ẏ  # Limit to first n numbers
   Π # Product of them

Pyke, 6 5 bytes
Sm.bB

Try it here!
product(map(nth_fib, input))

Maple, 40 bytes
`*`~(seq(combinat:-fibonacci(i),i=1..n))

Usage
> f:=n->`*`~(seq(combinat:-fibonacci(i),i=1..n));
> f(10);
  122522400

This uses the built-in combinat:-fibonacci as well as the element-wise operator ~ to multiply the terms in the sequence.

ngn/apl, 20 bytes
{×/(+/(!∘⌽⍨⍳))¨1+⍳⍵}

Try it here.
Explanation
{×/(+/(!∘⌽⍨⍳))¨1+⍳⍵}  Input: n
                  ⍵   Get n
                 ⍳    Form the range [0, 1, ..., n-1]
               1+     Add 1 to each to get [1, 2, ..., n]
              ¨       For each value x
           ⍳            Form the range [0, 1, ..., x-1]
         ⌽⍨             Reverse it to get [x-1, ..., 1, 0]
       !∘               Find the binomial coefficient between each pair in the original
                        range and reversed range
    +/                  Reduce using addition to get the xth Fibonacci number
 ×/                   Reduce using multiplication and return

Brain-Flak, 110 104 100 bytes
Try it online!
({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}([[]]()){({}()<({}<>)<>({<({}[()])><>({})<>}{})>)}{}

Explanation
First we run an improved version of the Fibonacci sequence generator curtesy of Dr Green Eggs and Iron Man
({}<((())<>)>){({}[()]<<>(({})<>({}<>)<>)>)}<>{}

Then while the stack has more than one item on it
([[]]()){({}()<...>)}

multiply the top two items
({}<>)<>({<({}[()])><>({})<>}{})

and pop the extra zero
{}

Unfortunately, I think this is invalid since it takes over 10 seconds for an input of 25. The algorithm is very inefficient (just like the language is), so calculating it for 100 would probably take hours.

PowerShell v3+, 86 bytes
param($n)$f=,1*$n;2..$n|%{$f[$_]=$f[$_-1]+$f[$_-2]};"[bigint]"+($f[0..$n]-join'*')|iex

The [bigint] data structure was introduced in .NET Framework 4, hence the PowerShell v3+ requirement.
Takes input $n, constructs a new array $f pre-populated with 1s, of length $n. Then we loop from 2..$n and each iteration simply construct the next Fibonacci value. Finally, we take $f from 0 up to $n and -join it together with * (so we have a big ol' string like 1*1*2*3*5*8*...), prepend that string with the cast "[bigint]", and pipe that to |iex (short for Invoke-Expression and similar to eval). The result is left on the pipeline, and output is implicit. We get by with only one data cast, as PowerShell uses the explicit cast from the left-hand-side of an operator as an implicit cast on the right-hand-side.
Tosses an array-index-out-of-bounds style exception to STDERR, but that's shorter than setting the loop to 2..($n-1) ;-)

If we didn't need to go higher than ~55, we can get rid of the cast and parens for the following at 73 bytes. Input values above 13 will result in scientific notation output.
param($n)$f=,1*$n;2..$n|%{$f[$_]=$f[$_-1]+$f[$_-2]};$f[0..$n]-join'*'|iex

05AB1E, 12 bytes
X$ÍF‚D`ŠŠO}P

Explanation
X$           # push 1, 1, input
  ÍF      }  # input-2 times do:
    ‚D       # pair top 2 elments and duplicate
      `ŠŠ    # flatten one pair and move the remaining pair to the top of the stack
         O   # sum the pair
           P # product of stack
             # implicitly print

Try it online

ÅF - Fibonacci numbers.

Fourier, 34 bytes
Basically, just a small tweak of the Fibonacci sequence program on Fourier's esolangs page.
1~F~x~yI~k(x*F~Fy+x~gy~xg~yi^~i)Fo

If you want to try this program online, I would suggest using Dennis' site, http://fourier.tryitonline.net, because on http://labs.turbo.run/beta/fourier an input of 100 leads to an output of infinity.
Try it online!

Lithp, 362 bytes
(
    (platform v1)
    (import "lists")
    (var FL (dict))
    (def fib #N::((if (< N 2) (1) ((+ (fibFL (- N 1)) (fibFL (- N 2)))))))
    (def fibFL #N::((if (dict-present FL N) ((dict-get FL N)) ((var I (fib N)) (set FL (dict-set FL N I)) (I)))))
    (def fib-orial #N::((prod (map (seq 1 N) (scope #I::((fib I)))))))
    (each (seq 2 15) (scope #N :: ((print (fib-orial N)))))
)

As with the JavaScript answer, rounding errors occur at orial of 16. Therefore this program prints the orial of 2 to 15.
This one was tricky, because the run time was well over 10 seconds for even a small number.
I solved this by using a dictionary to store results of calls to fib. The result is that instead of 10 seconds and over 100,000 function calls, the code often runs in under 200ms and results in only ~6700 function calls.

Pushy, 12 bytes
1&{2-:2d+;P#

Try it online!
This is a straightforward implementation of the specification:
1&    \ Push 1, twice.
{     \ Shift stack left (so input is on top).
      \ Stack: [1, 1, n]

2-:   \ Input - 2 times do (this consume input):
2d+;  \   Push the sum of the last 2 values.
      \ Stack: [fib(1), fib(2)... fib(n)]

P#    \ Output the stack product.

R, 36 34 bytes
prod(numbers::fibonacci(scan(),T))

Takes input from stdin. -2 bytes due to @Jardo Dubbeldam.

prod(numbers::fibonacci(scan(),T)) is a shorter builtin implementation :)

@JarkoDubbeldam Haha, thanks! You would think I would have tried that, given I was just talking to you about that function...

Javascript, 44 bytes
n=>eval(`for(c=a=b=1;--n;b+=t)t=a,c*=a=b;c`)

based on this Fibbonaci sequence

i think you can remove the brackets after eval?

J, 30 Bytes
*/@:([{.(,{:+{:@}:)@]^:[&1 1x)

Probably improvable.
Explanation:
*/@:(                        )    | Product of
     [{.                          | First n
        (,{:+{:@}:)@]^:[&1 1x     | n+2 fibonacci numbers:
                        &1 1x     | Apply with the list 1 1 (x specifies extended prescision)
                     ^:[          | n times:
        (,{:+{:@}:)@]             | Append the sum of the last two numbers

Computes the Fibonacc-orial of 100 in 2 ms.

Scala, 84 bytes
def f(i:Int,v:BigInt=1,p:BigInt=0,c:BigInt=1):BigInt=if(i==0)c else f(i-1,v+p,v,c*v)

Tail recursive function, based on this Fibonnaci implementation. This version adds a parameter to keep track of the running product.
Run it online (with test cases)

Jelly, 4 bytes
RÆḞP

Try it online!
Explanation
R       inclusive range
 ÆḞ     nth fibonacci number
   P    product

Japt, 7 bytes
õ@MgXÃ×

Try it

Explanation
õ         :Range [1,input]
 @   Ã    :Pass each X through a function
  MgX     :  Xth Fibonacci number
      ×   :Reduce by multiplication

Common Lisp, 65 bytes
(defun f(n &optional(a 1)(b 1))(if(< n 1)1(*(f(1- n)b(+ a b))a)))

Try it online!
Another port of Dennis's Python answer.
The straight iterative implementation is four bytes more:
(lambda(n)(do((x 1 y)(y 1(+ x y))(i 0(1+ i))(p 1(* p x)))((= i n)p)))

Stax, 5 bytes
Æn─⌂▄

Run and debug it
Unpacked it's
vOF|5*
v      decrement input by 1
 O     tuck 1 under top value of stack (in case input was one)
  F    turns rest of loop into a for loop for 1..(input-1)
   |5  get F(i+1)
     * multiply by running product

Lua, 76 bytes
Naïve solution (works until 14)
Try it online!
function I(x,a,b,c)return x<1 and c or I(x-1,a+b,a,a*c)end print(I(z,1,0,1))

Arbitrary-precision solution, using lua-nums (94 bytes)
--nums.bn is the name of the library as obtained from Luarocks
function I(x,a,b,c)return x<1 and c or I(x-1,a+b,require"nums.bn"(a),a*c)end print(I(z,1,0,1))

(Obviously you could rename the library in order to have shorter code, but this smells like cheating).
Timings for the second solution are:
real    0m0,030s
user    0m0,028s
sys 0m0,000s

Charcoal, 28 bytes
≔¹α≔¹β≔¹χＦＮ«≔×χαχ≔βα≔⁺αββ»Ｉχ

Try it online!

Factor + math.unicode, 43 bytes
[ 0 1 rot 1 - [ tuck + dup ] replicate Π ]

Try it online!

MathGolf, 4 bytes
╒fε*

Try it online.
Explanation:
╒     # Push a list in the range [1, (implicit) input]
 f    # Convert each to its Fibonacci value
  ε*  # Get the product of this list; reduce by multiplication
      # (after which the entire stack is output implicitly as result)


text:
Draw a Fibonacci Network!
What are Fibonacci networks?

In 1202, an Italian mathematician known as Fibonacci posed the following problem:
"A male and a female rabbit are born at the beginning of the year. We assume the following conditions:
1.After reaching the age of two months, each pair produces a mixed pair, (one male, one female), and then another mixed pair each month thereafter.
2.No deaths occur during the year."
How many rabbits will there be at the end of the year?

Sources for graph and problem statement
Challenge
Your challenge is to write a program/function to draw an ASCII art to output or a text file, or a graphical picture to a file/screen of a graph with following settings:

At 0th tick, there is one newly-born node.

Every newly born node creates a normal node after one tick after being born and gets deactivated.

A normal node creates a normal node and a newly-born node one tick after its birth and gets deactivated.

Your program will get the non-negative value n as input, and will draw the graph at the nth tick. Note that your program can draw newly-born nodes and normal nodes differently, but this is not necessary.
Rules

You must not use any built-in Fibonacci sequence function or mathematical constants or similar.

If your program outputs to a file, it must be either a text file in a suitable and viewable format and encoding, or an image file in a suitable and viewable format with recognizable colors (for example, an image format that can be uploaded to SE).

Your program can draw graph in any size, any shape and any alignment but the nodes and connections must be recognizable. Tree-shaped graphs (like the graph in "What are Fibonacci networks?" section) are recommended, but not necessary.

Common code golf rules apply to this challenge.

Examples
Input: 2
Possible Output:
*
|
*
| \
* *

Input: 0
Possible Output:
*

Input: 5
Possible Graphical Output:

This is a codegolf. Shortest code wins. Good luck!

Can you have a larger testcase?

@LeakyNun Well, every time i draw , i notice that i've drawn something wrong ... I'm trying hard to draw a larger test case ...

Then draw a larger testcase before uploading.

@LeakyNun http://meta.codegolf.stackexchange.com/a/9681/17602

@GLASSIC To draw the large test case, why not just write an ungolfed version of your challenge and run it?

@SocraticPhoenix I haven't solved it yet . I've made graph system already but i'm still trying to write an algorithm to generate the ascii art ... (I'm not a good programmer , nor a good codegolfer)

@GLASSIC according to your own challenge, output as an image is allowable. Couldn't you use that, at least for now?

I've started on this challenge. The mind boggles when you get past the first few months.

@Polyducks Yes. That is very true.

I think I've got it. You can draw it as modular pieces and change the scale as you go further down.

I've got a partial answer which would help other people. Should I post it and update as I fix it up? I'm not sure what the rules are for answers in this stack.

Pyth, 31 bytes
Ms+0m+Wd+J+G"| "+G1+\-gJtd_UHgb

Try it online
How it works
M                                  def g(G, H):
    m                     _UH        map for d in [H - 1, …, 0]:
         J+G"| "                       assign J = G + "| "
        +       +G1                    J + G + 1
     +Wd                               conditional +, if d is truthy (nonzero):
                   +\-gJtd               "-" + g(J, d - 1)
  +0                                 prepend 0
 s                                   concatenate
                             gbQ   g("\n", input)

Output for 6
0
|
1-0
| |
| 1-0
| | |
| | 1-0
| | |
| | 1
| |
| 1-0
| | |
| | 1
| |
| 1-0
| |
| 1
|
1-0
| |
| 1-0
| | |
| | 1
| |
| 1-0
| |
| 1
|
1-0
| |
| 1-0
| |
| 1
|
1-0
| |
| 1
|
1-0
|
1

Pyth, 43 bytes
Mc+WH`G++WG\-+j"
| "g0tH"
`-"j"
  "g1tHbjg0

Try it online
Output for 6
0-1-0-1-0-1-0
  |   |   `-1
  |   `-1-0-1
  |     `-1-0
  |       `-1
  `-1-0-1-0-1
    |   `-1-0
    |     `-1
    `-1-0-1-0
      |   `-1
      `-1-0-1
        `-1-0
          `-1

HTML5/JavaScript, 1262 bytes
This is my code which displays a Fibonacci network. You can just paste it into a file with a name like index.html and run it in your favourite browser (I only tested Chrome and Firefox though). When you launch it, it asks you for the desired number of generations. It uses the HTML5 <canvas> tag to display the image.
<script>let t,p,o,c=[],q=50,r=20,s=25;function d(o){return JSON.parse(JSON.stringify(o));}function e(a,x,y){o.beginPath();o.fillStyle=a?"red":"#000";o.arc(x*q+s,y*q+s,r,0,2*3.14159);o.fill();}function f(a,b,c,d){o.beginPath();o.strokeStyle="blue";o.lineWidth=3;o.moveTo(a*q+s,b*q+s);o.lineTo(c*q+s,d*q+s);o.stroke();}function g(i){return c[i].a+c[i].c;}function h(i){return c[i].b+c[i].d;}function k(j,e,f,b,n,x,y,z){f=j;b=0;while(1){if(!e){f.t=g(t);f.u=0;f.v=f.t;f.w=f.b;}else{n=t-b+1;x=t-b;z=e.b%2?(g(n)+g(x)+1):(-(g(n)+h(x)+1));f.t=e.v+z;f.u=e.w+1;f.v=f.t;f.w=f.u+f.b;}if(!f.a)break;b+=f.b+1;e=f;f=f.z;}return {a:f.b==0,x:f.v,y:f.w};}function l(j,c,b){b=k(j);f(b.x,b.y,c.x,c.y);e(b.a,b.x,b.y);return b;}function m(j){while(j.a)j=j.z;return j;}function n(j,o,p,q,r,s){if(o>t)return;q=l(j,p);r=d(j);m(r).b++;n(r,o+1,q);if(m(j).b>0){r=d(j);s=m(r);s.a=!0;s.z={a:!1,b:0};n(r,o+1,q);}}function b(i,z,y){t=parseInt(prompt());if(isNaN(t)||t<0)t=0;p=document.getElementById("o");c.push({a:0,b:0,c:0,d:0,e:1});for(i=1;i<t+1;i++){z=c[c.length-1];y={a:(i>1?i%2:0)+z.c,b:(i>1?1-i%2:0)+z.d,c:z.a+z.c,d:z.b+z.d};y.e=y.a+y.b+y.c+y.d;c.push(y);}p.width=q*(c[c.length-1].e+1);p.height=q*(t+1);o=p.getContext("2d");n({a:!1,b:0},0,0);}</script><body onload="b()"><canvas id="o">

An example for 6 generations would be this one:

As you can see, newly born nodes are colored in red, the others are black.
For reference, this is my ungolfed, development code that does exactly the same:

<html>
 <head>
  <meta charset="utf-8">
  <title>Fibonacci Graph</title>
  <script type="text/javascript">
   let totalGenerations;
   let canvas, ctx;
   let individualCount = [];
   let individualDrawSize = 50, individualDrawRadius = 20, individualDrawOffset = 25;

   function generateIndividualCount()
   {
    individualCount.push(
    {
     babiesL: 0,   //number of babies on the left side of the main individual
     babiesR: 0,
     adultsL: 0,
     adultsR: 0,
     total: 1   //total number of individuals (sum of all other members+1, because the main individual counts as well)
    });

    for(let i=1; i<totalGenerations+1; i++)
    {
     let last = individualCount[individualCount.length - 1];
     let next =
     {
      //make an adult alternate between having a baby at the left and the right side (right side first)
      babiesL: (i>1 ? i%2 : 0) + last.adultsL,
      babiesR: (i>1 ? 1-i%2 : 0) + last.adultsR,
      adultsL: last.babiesL + last.adultsL,
      adultsR: last.babiesR + last.adultsR
     };
     next.total = next.babiesL + next.babiesR + next.adultsL + next.adultsR;
     individualCount.push(next);
    }
   }

   function setupContext()
   {
    canvas.width = individualDrawSize * (individualCount[individualCount.length - 1].total + 1);
    canvas.height = individualDrawSize * (totalGenerations + 1);
    ctx = canvas.getContext("2d");
   }

   function deepCopy(obj)
   {
    return JSON.parse(JSON.stringify(obj));
   }

   function drawIndividual(isBaby, x, y)
   {
    ctx.beginPath();
    ctx.fillStyle = isBaby ? "red" : "black";
    ctx.arc(x*individualDrawSize + individualDrawOffset, y*individualDrawSize + individualDrawOffset, individualDrawRadius, 0, 2*Math.PI);
    ctx.fill();
   }

   function drawLine(x1, y1, x2, y2)
   {
    ctx.beginPath();
    ctx.strokeStyle = "blue";
    ctx.lineWidth = 3;
    ctx.moveTo(x1*individualDrawSize + individualDrawOffset, y1*individualDrawSize + individualDrawOffset);
    ctx.lineTo(x2*individualDrawSize + individualDrawOffset, y2*individualDrawSize + individualDrawOffset);
    ctx.stroke();
   }

   function getIndividualCountLeft(i)  //left like in "the opposite of right"
   {
    return individualCount[i].babiesL + individualCount[i].adultsL;
   }

   function getIndividualCountRight(i)
   {
    return individualCount[i].babiesR + individualCount[i].adultsR;
   }

   function getPosition(ancestorInformation)
   {
    let prevInfo;
    let tempInfo = ancestorInformation;
    let currDepth = 0;

    while(1)
    {
     if(prevInfo == undefined)
     {
      tempInfo.birthX = getIndividualCountLeft(totalGenerations);
      tempInfo.birthY = 0;

      tempInfo.givingBirthX = tempInfo.birthX;
      tempInfo.givingBirthY = tempInfo.ageAtGivingBirth;
     }
     else
     {
      let generationsLeftForParent = totalGenerations - (currDepth-1);
      let generationsLeftForChild = totalGenerations - currDepth;    //left like in "to go" or "There are 42 cookies left"
      let isLeftBranch = (prevInfo.ageAtGivingBirth % 2 == 0);
      let distanceToParent;

      if(isLeftBranch)
       distanceToParent = -(getIndividualCountLeft(generationsLeftForParent) + getIndividualCountRight(generationsLeftForChild) + 1);
      else
       //some of these directions may seem odd, but because the parent subtree begins with a left branch (and individualCount only contains data for trees beginning with a right branch), it needs to be inversed
       //if individualCount would have been generated for trees beginning with a left node, all of the getIndividualCountLeft/getIndividualCountRight function would need to be inversed
       //or, when individualCount would have been generated for both cases, functions like getIndividualCountRight_LeftBegin and getIndividualCountLeft_RightBegin could be used
       distanceToParent = getIndividualCountLeft(generationsLeftForParent) + getIndividualCountLeft(generationsLeftForChild) + 1;  //+1, because the previous value of distanceToParent is just the number of empty fields (on the x axis) between the parent and the child

      tempInfo.birthX = prevInfo.givingBirthX + distanceToParent;
      tempInfo.birthY = prevInfo.givingBirthY + 1;

      tempInfo.givingBirthX = tempInfo.birthX;
      tempInfo.givingBirthY = tempInfo.birthY + tempInfo.ageAtGivingBirth;
     }
     if(!tempInfo.isParent)
      break;
     currDepth += tempInfo.ageAtGivingBirth + 1;
     prevInfo = tempInfo;
     tempInfo = tempInfo.child;
    }

    return { isBaby: tempInfo.ageAtGivingBirth==0, x: tempInfo.givingBirthX, y: tempInfo.givingBirthY };
   }

   function draw(ancestorInformation, parentPos)
   {
    let pos = getPosition(ancestorInformation);
    drawLine(pos.x, pos.y, parentPos.x, parentPos.y);
    drawIndividual(pos.isBaby, pos.x, pos.y);
    return pos;
   }

   function getDeepestChild(ancestorInformation)
   {
    while(ancestorInformation.isParent)
     ancestorInformation = ancestorInformation.child;
    return ancestorInformation;
   }

   function drawAll(ancestorInformation, depth, parentPos)
   {
    if(depth > totalGenerations)
     return;

    let pos = draw(ancestorInformation, parentPos);
    let newAncestorInformation = deepCopy(ancestorInformation);
    getDeepestChild(newAncestorInformation).ageAtGivingBirth++;
    drawAll(newAncestorInformation, depth + 1, pos);

    if(getDeepestChild(ancestorInformation).ageAtGivingBirth > 0)
    {
     newAncestorInformation = deepCopy(ancestorInformation);
     let deepestChild = getDeepestChild(newAncestorInformation);
     deepestChild.isParent = true;
     deepestChild.child = { isParent: false, ageAtGivingBirth: 0 };
     drawAll(newAncestorInformation, depth + 1, pos);
    }
   }

   function load()
   {
    totalGenerations = parseInt(prompt("Number of generations?"));
    if(isNaN(totalGenerations)  ||  totalGenerations < 0)
     totalGenerations = 0;
    canvas = document.getElementById("output");
    generateIndividualCount();
    setupContext();
    drawAll({ isParent: false, ageAtGivingBirth: 0 }, 0, 0);     //although this individual does not really give birth after it has been born, it still has an attribute called "ageAtGivingBirth" (like its parents) to achieve a similar effect
   }
  </script>
 </head>
 <body onload="load()">
  <canvas id="output" style="position:absolute; top:10px; left:10px" width="1200" height="600">Canvas not supported...</canvas>
 </body>
</html>

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Verify Wolstenholme's theorem
Definition
Wolstenholme's theorem states that:

where  a and b are positive integers and p is prime, and the big parentheses thingy is Binomial coefficient.
Task
To verify that, you will be given three inputs: a, b, p, where a and b are positive integers and p is prime.
Compute:

where  a and b are positive integers and p is prime, and the parentheses thingy is Binomial coefficient.
Specs
Since:

where and the parentheses thingy is Binomial coefficient.
You can assume that 2b <= a
Testcases
a b p  output
6 2 5  240360
3 1 13 3697053
7 3 13 37403621741662802118325

I feel like outputs should have a .0 on the end, to really show that there's no leftover.from the division.

@El'endiaStarman Come on.

Would [240360] (singleton array) be an acceptable output format?

@Dennis Where's the meta for this?

I don't think there is one, which is why I'm asking.

@Dennis Then make one.

@LuisMendo clarificado

@LeakyNun Gracias :-) Can we compute the negative of that fraction? It's equally valid to test if it's zero

@LuisMendo Eh, I'd say no.

Not a bad idea, but it wouldn't reapply retroactively to your challenge anyway, so you'd still have to make the call.

@Dennis If meta approves singleton array I'll let you retroactively do it.

What does "verify" mean? If you compute the ratio (binom - binom)/p^3 using integer division, the answer will always be a whole number, so you've verified nothing.

Haskell, 73 71 bytes
Due to the recursion, this implementation is very slow. Unfortunately my definition of the binomial coefficient has the same length as import Math.Combinatorics.Exact.Binomial.
n#k|k<1||k>=n=1|1>0=(n-1)#(k-1)+(n-1)#k --binomial coefficient
f a b p=div((a*p)#(b*p)-a#b)p^3       --given formula

An interesting oddity is that Haskell 98 did allow for arithmetic patterns which would have shortened the same code to 64 bytes:
g a b p=div((a*p)#(b*p)-a#b)p^3
n+1#k|k<1||k>n=1|1>0=n#(k-1)+n#k

Shouldn't the Haskell 98 version still be a valid submission?

Jelly, 12 11 10 bytes
ż×c/I÷S÷²}

Expects a, b and p as command-line arguments.
Try it online! or verify all test cases.
How it works
ż×c/I÷S÷²}  Main link. Left argument: a, b. Right argument: p

 ×          Multiply; yield [pa, pb].
ż           Zipwith; yield [[a, pa], [b, pb]].
  c/        Reduce columns by combinations, yielding [aCb, (pa)C(pb)].
    I       Increments; yield [(pa)C(pb) - aCb].
     ÷      Divide; yield [((pa)C(pb) - aCb) ÷ p].
      S     Sum; yield ((pa)C(pb) - aCb) ÷ p.
        ²}  Square right; yield p².
       ÷    Divide; yield  ((pa)C(pb) - aCb) ÷ p³.

Python 2, 114 109 85 71 bytes
A simple implementation. Golfing suggestions welcome.
Edit: -29 bytes thanks to Leaky Nun and -14 bytes thanks to Dennis.
lambda a,b,p,f=lambda n,m:m<1or f(n-1,m-1)*n/m:(f(a*p,b*p)-f(a,b))/p**3

A simpler, same-length alternative, with thanks to Dennis, is
f=lambda n,m:m<1or f(n-1,m-1)*n/m
lambda a,b,p:(f(a*p,b*p)-f(a,b))/p**3

Here is a golfed factorial lambda

05AB1E, 11 bytes
Takes input as:
[a, b]
p

Code:
*`c¹`c-²3m÷

Uses the CP-1252 encoding. Try it online!.

Did you out-golf Dennis?

If I were in Dennis' shoes I think I'd get a little tired of all these "outgolf Dennis" comments...

@LuisMendo I may or may not be nuking them on a regular basis.

and hes at 10. it was fun while it lasted boys

R, 50 48 bytes
function(a,b,p)(choose(a*p,b*p)-choose(a,b))/p^3

As straightforward as can be...
Thanks to @Neil for saving 2 bytes.

How many of those spaces are necessary?

42 bytes by renaming choose and by using pryr::f to define the function: B=choose;pryr::f((B(a*p,b*p)-B(a,b))/p^3).

MATL, 13 bytes
y*hZ}Xnd2G3^/

Try it online!
The last test case doesn't produce an exact integer due to numerical precision. MATL's default data type (double) can only handle exact integers up to 2^53.
Explanation
y   % Implicitly input [a; b] (col vector) and p (number). Push another copy of [a; b]
    %   Stack: [a; b], p, [a; b]
*   % Multiply the top two elements from the stack
    %   Stack: [a; b], [a*p; b*p]
h   % Concatenate horizontally
    %   Stack: [a, a*p; b, b*p]
Z}  % Split along first dimension
    %   Stack: [a, a*p], [b, b*p]
Xn  % Vectorize nchoosek
    %   Stack: [nchoosek(a,b), nchoosek(a*p,b*p)]
d   % Consecutive differences of array
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p)
2G  % Push second input again
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p), p
3^  % Raise to third power
    %   Stack: nchoosek(a,b)-nchoosek(a*p,b*p), p^3
/   % Divide top two elements from the stack
    %   Stack: (nchoosek(a,b)-nchoosek(a*p,b*p))/p^3
    % Implicitly display

J, 17 bytes
(!/@:*-!/@[)%]^3:

Usage
(b,a) ( (!/@:*-!/@[)%]^3: ) p

For example:
   2 6 ( (!/@:*-!/@[)%]^3: ) 5
240360

This is just a direct implementation of the formula so far.
Note: for the 3rd testcase input numbers must be defined as extended (to handle big arithmetic):
   3x 7x ( (!/@:*-!/@[)%]^3: ) 13x
37403621741662802118325

Brachylog, 52 bytes
tT;T P&t^₃D&h↰₁S&h;Pz×₎ᵐ↰₁;S-;D/
hḟF&⟨{-ḟ}×{tḟ}⟩;F↻/

Try it online!
Accepts input [[a, b], p].
% Predicate 1 - Given [n, r], return binomial(n, r)
hḟF              % Compute n!, set as F
&⟨               % Fork:
  {-ḟ}           % (n - r)!
  ×              % times
  {tḟ}           % r!
⟩
;F↻              % Prepend n! to that
/                % Divide n! by the product and return

% Predicate 0 (Main)
tT;T P           % Set P to the array [p, p]
&t^₃D            % Set D as p^3
&h↰₁S            % Call predicate 1 on [a, b],
                 %  set S as the result binomial(a, b)
&h;Pz×₎ᵐ         % Form array [ap, bp]
↰₁               % Call predicate 1 on that to get binomial(ap, bp)
;S-              % Get binomial(ap, bp) - binomial(a, b)
;D/              % Divide that by the denominator term p^3
                 % Implicit output

Nim, 85 82 75 59 bytes
import math,future
(a,b,p)=>(binom(a*p,b*p)-binom(a,b))/p^3

This is an anonymous procedure; to use it, it must be passed as an argument to another procedure, which prints it. A full program that can be used for testing is given below
import math,future
proc test(x: (int, int, int) -> float) =
 echo x(3, 1, 13) # substitute in your input or read from STDIN
test((a,b,p)=>(binom(a*p,b*p)-binom(a,b))/p^3)

Nim's math module's binom proc computes the binomial coefficient of its two arguments.

Python 3 with SciPy, 72 bytes
from scipy.special import*
lambda a,b,p:(binom(a*p,b*p)-binom(a,b))/p**3

An anonymous function that takes input via argument and returns the result.
There's not a lot going on here; this is a direct implementation of the desired computation.
Try it on Ideone (the result is returned in exponential notation for the last test case)

Python 2, 67 bytes
def f(a,b,p):B=2<<a*p;R=(B+1)**a;print(R**p/B**(p*b)-R/B**b)%B/p**3

Try it online!
Expresses the binomial coefficients arithmetically using this method.

JavaScript (ES6), 70 bytes
(a,b,p,c=(a,b)=>a==b|!b||c(--a,b)+c(a,--b))=>(c(a*p,b*p)-c(a,b))/p/p/p

Save 1 byte by using ES7 (/p**3 instead of /p/p/p).

APL (Dyalog), 18 bytes
{(-/!/¨⍺1×⊂⍵)÷⍺*3}

Try it online!

Pari/GP, 43 bytes
(a,b,p)->((c=binomial)(a*p,b*p)-c(a,b))/p^3

Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/