Compute nCr%p using Fermat Little Theorem

Given three numbers n, r and p, compute the value of ⁿC_r mod p. Here p is a prime number greater than n. Here ⁿC_r is Binomial Coefficient.
Example: 

Input: n = 10, r = 2, p = 13
Output: 6
Explanation: 10C2 is 45 and 45 % 13 is 6.

Input: n = 6, r = 2, p = 13
Output: 2

We have discussed the following methods in previous posts. 
Compute ⁿC_r % p | Set 1 (Introduction and Dynamic Programming Solution) 
Compute ⁿC_r % p | Set 2 (Lucas Theorem)
In this post, Fermat Theorem-based solution is discussed.
Background: 
Fermat's little theorem and modular inverse 
Fermat's little theorem states that if p is a prime number, then for any integer a, the number a^p - a is an integer multiple of p. In the notation of modular arithmetic, this is expressed as: 
a^p = a (mod p) 
For example, if a = 2 and p = 7, 2⁷ = 128, and 128 - 2 = 7 × 18 is an integer multiple of 7.
If a is not divisible by p, Fermat's little theorem is equivalent to the statement a ^{p - 1} - 1 is an integer multiple of p, i.e 
a^p-1 = 1 (mod p)
If we multiply both sides by a^-1, we get. 
a^p-2 = a^-1 (mod p)
So we can find modular inverse as ^p-2. 
Computation: 

We know the formula for nCr 
nCr = fact(n) / (fact(r) x fact(n-r)) 
Here fact() means factorial.

 nCr % p = (fac[n]* modIverse(fac[r]) % p *
 modIverse(fac[n-r]) % p) % p;
Here modIverse() means modular inverse under
modulo p.

Following is the implementation of the above algorithm. In the following implementation, an array fac[] is used to store all the computed factorial values. 

Value of nCr % p is 6

Time Complexity: O(n)
Auxiliary Space: O(n)

We can further improve it's space complexity:

Instead of calculating factorial in a different array, we can directly multiply numbers with some cancellations.

We know the formula for nCr 
nCr = fact(n) / (fact(r) x fact(n-r)) 
fact(n) = n * (n-1) * (n-2) * (n-3)* .... * 1;
fact(r) = r * (r-1) * (r-2) * ......... *1;
Because r is always less than n in nCr So all factors in fact(r) also come in fact(n),
hence we can cancell them.
And get the multiplication of rest elements of numerator and denominator(fact(n-r))
Note that rest elements of numerator will be n* (n-1) *(n-2) * .... (r+1).

We can also improve time complexity with the logic nCr is equal to nC(n-r). So whenever n-r is less than r compute nCn-r instead of nCr.

See the below implementation:

Value of nCr % p is 6

Time Complexity: O(n)
Auxiliary Space: O(1)

Improvements: 
In competitive programming, we can pre-compute fac[] for a given upper limit so that we don't have to compute it for every test case. We also can use unsigned long long int everywhere to avoid overflows.