Compute n! under modulo p - GeeksforGeeks

26 Apr, 2022
Given a large number n and a prime p, how to efficiently compute n! % p?Examples :  
Input:  n = 5, p = 13
Output: 3
5! = 120 and 120 % 13 = 3

Input:  n = 6, p = 11
Output: 5
6! = 720 and 720 % 11 = 5
A Naive Solution is to first compute n!, then compute n! % p. This solution works fine when the value of n! is small. The value of n! % p is generally needed for large values of n when n! cannot fit in a variable, and causes overflow. So computing n! and then using modular operator is not a good idea as there will be overflow even for slightly larger values of n and r. Following are different methods.Method 1 (Simple) A Simple Solution is to one by one multiply result with i under modulo p. So the value of result doesn’t go beyond p before next iteration. 
C++
Java
Python3
C#
PHP
Javascript
// Simple method to compute n! % p#include <bits/stdc++.h>using namespace std; // Returns value of n! % pint modFact(int n, int p){    if (n >= p)        return 0;     int result = 1;    for (int i = 1; i <= n; i++)        result = (result * i) % p;     return result;} // Driver programint main(){    int n = 25, p = 29;    cout << modFact(n, p);    return 0;}
// Simple method to compute n! % pimport java.io.*; class GFG{    // Returns value of n! % p    static int modFact(int n,                       int p)    {        if (n >= p)            return 0;             int result = 1;        for (int i = 1; i <= n; i++)            result = (result * i) % p;             return result;    }         // Driver Code    public static void main (String[] args)    {        int n = 25, p = 29;        System.out.print(modFact(n, p));    }} // This code is contributed// by aj_36
# Simple method to compute n ! % p # Returns value of n ! % pdef modFact(n, p):    if n >= p:        return 0        result = 1    for i in range(1, n + 1):        result = (result * i) % p     return result # Driver Coden = 25; p = 29print (modFact(n, p)) # This code is contributed by Shreyanshi Arun.
// Simple method to compute n! % pusing System;  class GFG {          // Returns value of n! % p    static int modFact(int n, int p)    {        if (n >= p)            return 0;             int result = 1;        for (int i = 1; i <= n; i++)            result = (result * i) % p;             return result;    }         // Driver program    static void Main()    {        int n = 25, p = 29;        Console.Write(modFact(n, p));    }} // This code is contributed by Anuj_67
<?php// PHP Simple method to compute n! % p // Returns value of n! % pfunction modFact($n, $p){    if ($n >= $p)    return 0;     $result = 1;    for ($i = 1; $i <= $n; $i++)        $result = ($result * $i) % $p;     return $result;} // Driver Code$n = 25; $p = 29;echo modFact($n, $p); // This code is contributed by Ajit.?>
<script> // Simple method to compute n! % p     // Returns value of n! % p     function modFact(n,p)    {        if (n >= p)            return 0;             let result = 1;        for (let i = 1; i <= n; i++)            result = (result * i) % p;             return result;    }         // Driver Code             let n = 25, p = 29;        document.write(modFact(n, p)); // This code is contributed by Rajput-Ji </script>
Output : 
5
Time Complexity of this solution is O(n).Method 2 (Using Sieve) The idea is based on below formula discussed here. 
The largest possible power of a prime pi that divides n is,
    ⌊n/pi⌋ + ⌊n/(pi2)⌋ +  ⌊n/(pi3)⌋ + .....+ 0 

Every integer can be written as multiplication of powers of primes.  So,
  n! = p1k1 * p2k2 * p3k3 * ....
  Where p1, p2, p3, .. are primes and 
        k1, k2, k3, .. are integers greater than or equal to 1.
The idea is to find all primes smaller than n using Sieve of Eratosthenes. For every prime ‘pi‘, find the largest power of it that divides n!. Let the largest power be ki. Compute piki % p using modular exponentiation. Multiply this with final result under modulo p.Below is implementation of above idea. 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to Returns n % p// using Sieve of Eratosthenes#include <bits/stdc++.h>using namespace std; // Returns largest power of p that divides n!int largestPower(int n, int p){    // Initialize result    int x = 0;     // Calculate x = n/p + n/(p^2) + n/(p^3) + ....    while (n) {        n /= p;        x += n;    }    return x;} // Utility function to do modular exponentiation.// It returns (x^y) % pint power(int x, int y, int p){    int res = 1; // Initialize result    x = x % p; // Update x if it is more than or    // equal to p    while (y > 0) {        // If y is odd, multiply x with result        if (y & 1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Returns n! % pint modFact(int n, int p){    if (n >= p)        return 0;     int res = 1;     // Use Sieve of Eratosthenes to find all primes    // smaller than n    bool isPrime[n + 1];    memset(isPrime, 1, sizeof(isPrime));    for (int i = 2; i * i <= n; i++) {        if (isPrime[i]) {            for (int j = 2 * i; j <= n; j += i)                isPrime[j] = 0;        }    }     // Consider all primes found by Sieve    for (int i = 2; i <= n; i++) {        if (isPrime[i]) {            // Find the largest power of prime 'i' that divides n            int k = largestPower(n, i);             // Multiply result with (i^k) % p            res = (res * power(i, k, p)) % p;        }    }    return res;} // Driver methodint main(){    int n = 25, p = 29;    cout << modFact(n, p);    return 0;}
import java.util.Arrays; // Java program Returns n % p using Sieve of Eratosthenespublic class GFG { // Returns largest power of p that divides n!    static int largestPower(int n, int p) {        // Initialize result        int x = 0;         // Calculate x = n/p + n/(p^2) + n/(p^3) + ....        while (n > 0) {            n /= p;            x += n;        }        return x;    } // Utility function to do modular exponentiation.// It returns (x^y) % p    static int power(int x, int y, int p) {        int res = 1; // Initialize result        x = x % p; // Update x if it is more than or        // equal to p        while (y > 0) {            // If y is odd, multiply x with result            if (y % 2 == 1) {                res = (res * x) % p;            }             // y must be even now            y = y >> 1; // y = y/2            x = (x * x) % p;        }        return res;    } // Returns n! % p    static int modFact(int n, int p) {        if (n >= p) {            return 0;        }         int res = 1;         // Use Sieve of Eratosthenes to find all primes        // smaller than n        boolean isPrime[] = new boolean[n + 1];        Arrays.fill(isPrime, true);        for (int i = 2; i * i <= n; i++) {            if (isPrime[i]) {                for (int j = 2 * i; j <= n; j += i) {                    isPrime[j] = false;                }            }        }         // Consider all primes found by Sieve        for (int i = 2; i <= n; i++) {            if (isPrime[i]) {                // Find the largest power of prime 'i' that divides n                int k = largestPower(n, i);                 // Multiply result with (i^k) % p                res = (res * power(i, k, p)) % p;            }        }        return res;    } // Driver method    static public void main(String[] args) {        int n = 25, p = 29;        System.out.println(modFact(n, p));     }}// This code is contributed by Rajput-Ji
# Python3 program to Returns n % p# using Sieve of Eratosthenes # Returns largest power of p that divides n!def largestPower(n, p):         # Initialize result    x = 0         # Calculate x = n/p + n/(p^2) + n/(p^3) + ....    while (n):        n //= p        x += n    return x # Utility function to do modular exponentiation.# It returns (x^y) % pdef power( x, y, p):    res = 1 # Initialize result    x = x % p # Update x if it is more than              # or equal to p    while (y > 0) :                 # If y is odd, multiply x with result        if (y & 1) :            res = (res * x) % p         # y must be even now        y = y >> 1 # y = y/2        x = (x * x) % p     return res # Returns n! % pdef modFact( n, p) :     if (n >= p) :        return 0     res = 1     # Use Sieve of Eratosthenes to find    # all primes smaller than n    isPrime = [1] * (n + 1)    i = 2    while(i * i <= n):        if (isPrime[i]):            for j in range(2 * i, n, i) :                isPrime[j] = 0        i += 1             # Consider all primes found by Sieve    for i in range(2, n):        if (isPrime[i]) :                         # Find the largest power of prime 'i'            # that divides n            k = largestPower(n, i)             # Multiply result with (i^k) % p            res = (res * power(i, k, p)) % p     return res # Driver codeif __name__ =="__main__":    n = 25    p = 29    print(modFact(n, p)) # This code is contributed by# Shubham Singh(SHUBHAMSINGH10)
// C# program Returns n % p using Sieve of Eratosthenesusing System;  public class GFG { // Returns largest power of p that divides n!    static int largestPower(int n, int p) {        // Initialize result        int x = 0;         // Calculate x = n/p + n/(p^2) + n/(p^3) + ....        while (n > 0) {            n /= p;            x += n;        }        return x;    } // Utility function to do modular exponentiation.// It returns (x^y) % p    static int power(int x, int y, int p) {        int res = 1; // Initialize result        x = x % p; // Update x if it is more than or        // equal to p        while (y > 0) {            // If y is odd, multiply x with result            if (y % 2 == 1) {                res = (res * x) % p;            }             // y must be even now            y = y >> 1; // y = y/2            x = (x * x) % p;        }        return res;    } // Returns n! % p    static int modFact(int n, int p) {        if (n >= p) {            return 0;        }         int res = 1;         // Use Sieve of Eratosthenes to find all primes        // smaller than n        bool []isPrime = new bool[n + 1];        for(int i = 0;i<n+1;i++)            isPrime[i] = true;        for (int i = 2; i * i <= n; i++) {            if (isPrime[i]) {                for (int j = 2 * i; j <= n; j += i) {                    isPrime[j] = false;                }            }        }         // Consider all primes found by Sieve        for (int i = 2; i <= n; i++) {            if (isPrime[i]) {                // Find the largest power of prime 'i' that divides n                int k = largestPower(n, i);                 // Multiply result with (i^k) % p                res = (res * power(i, k, p)) % p;            }        }        return res;    } // Driver method    static public void Main() {        int n = 25, p = 29;        Console.WriteLine(modFact(n, p));     }}// This code is contributed by PrinciRaj19992
<?php// PHP program to Returns n % p// using Sieve of Eratosthenes // Returns largest power of p that// divides n!function largestPower($n, $p){    // Initialize result    $x = 0;     // Calculate x = n/p + n/(p^2) + n/(p^3) + ....    while ($n)    {        $n = (int)($n / $p);        $x += $n;    }    return $x;} // Utility function to do modular exponentiation.// It returns (x^y) % pfunction power($x, $y, $p){    $res = 1; // Initialize result    $x = $x % $p; // Update x if it is more                  // than or equal to p    while ($y > 0)    {        // If y is odd, multiply x with result        if ($y & 1)            $res = ($res * $x) % $p;         // y must be even now        $y = $y >> 1; // y = y/2        $x = ($x * $x) % $p;    }    return $res;} // Returns n! % pfunction modFact($n, $p){    if ($n >= $p)        return 0;     $res = 1;     // Use Sieve of Eratosthenes to find    // all primes smaller than n    $isPrime = array_fill(0, $n + 1, true);    for ($i = 2; $i * $i <= $n; $i++)    {        if ($isPrime[$i])        {            for ($j = 2 * $i; $j <= $n; $j += $i)                $isPrime[$j] = 0;        }    }     // Consider all primes found by Sieve    for ($i = 2; $i <= $n; $i++)    {        if ($isPrime[$i])        {            // Find the largest power of            // prime 'i' that divides n            $k = largestPower($n, $i);             // Multiply result with (i^k) % p            $res = ($res * power($i, $k, $p)) % $p;        }    }    return $res;} // Driver Code$n = 25;$p = 29;echo modFact($n, $p); // This code is contributed by mits?>
<script>     // Javascript program Returns n % p    // using Sieve of Eratosthenes         // Returns largest power of p    // that divides n!    function largestPower(n, p)    {        // Initialize result        let x = 0;          // Calculate x = n/p + n/(p^2) +        // n/(p^3) + ....        while (n > 0) {            n = parseInt(n / p, 10);            x += n;        }        return x;    }      // Utility function to do    // modular exponentiation.    // It returns (x^y) % p    function power(x, y, p)    {    // Initialize result        let res = 1;   // Update x if it is more than or        x = x % p;        // equal to p        while (y > 0) {   // If y is odd, multiply x with result            if (y % 2 == 1) {                res = (res * x) % p;            }              // y must be even now            y = y >> 1; // y = y/2            x = (x * x) % p;        }        return res;    }      // Returns n! % p    function modFact(n, p) {        if (n >= p) {            return 0;        }          let res = 1;          // Use Sieve of Eratosthenes        // to find all primes        // smaller than n        let isPrime = new Array(n + 1);        for(let i = 0;i<n+1;i++)            isPrime[i] = true;        for (let i = 2; i * i <= n; i++) {            if (isPrime[i]) {                for (let j = 2 * i; j <= n; j += i)                {                    isPrime[j] = false;                }            }        }          // Consider all primes found by Sieve        for (let i = 2; i <= n; i++) {            if (isPrime[i]) {                // Find the largest power of                // prime 'i' that divides n                let k = largestPower(n, i);                  // Multiply result with (i^k) % p                res = (res * power(i, k, p)) % p;            }        }        return res;    }         let n = 25, p = 29;      document.write(modFact(n, p));     </script>
Output: 
5
This is an interesting method, but time complexity of this is more than Simple Method as time complexity of Sieve itself is O(n log log n). This method can be useful if we have list of prime numbers smaller than or equal to n available to us.Method 3 (Using Wilson’s Theorem) Wilson’s theorem states that a natural number p > 1 is a prime number if and only if 
    (p - 1) ! ≡ -1   mod p 
OR  (p - 1) ! ≡  (p-1) mod p 
Note that n! % p is 0 if n >= p. This method is mainly useful when p is close to input number n. For example (25! % 29). From Wilson’s theorem, we know that 28! is -1. So we basically need to find [ (-1) * inverse(28, 29) * inverse(27, 29) * inverse(26) ] % 29. The inverse function inverse(x, p) returns inverse of x under modulo p (See this for details).  
C++
Java
Python3
C#
PHP
Javascript
// C++ program to compute n! % p using Wilson's Theorem#include <bits/stdc++.h>using namespace std; // Utility function to do modular exponentiation.// It returns (x^y) % pint power(int x, unsigned int y, int p){    int res = 1; // Initialize result    x = x % p; // Update x if it is more than or    // equal to p    while (y > 0) {        // If y is odd, multiply x with result        if (y & 1)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Function to find modular inverse of a under modulo p// using Fermat's method. Assumption: p is primeint modInverse(int a, int p){    return power(a, p - 2, p);} // Returns n! % p using Wilson's Theoremint modFact(int n, int p){    // n! % p is 0 if n >= p    if (p <= n)        return 0;     // Initialize result as (p-1)! which is -1 or (p-1)    int res = (p - 1);     // Multiply modulo inverse of all numbers from (n+1)    // to p    for (int i = n + 1; i < p; i++)        res = (res * modInverse(i, p)) % p;    return res;} // Driver methodint main(){    int n = 25, p = 29;    cout << modFact(n, p);    return 0;}
// Java program to compute n! % p// using Wilson's Theoremclass GFG{     // Utility function to do// modular exponentiation.// It returns (x^y) % pstatic int power(int x, int y, int p){    int res = 1; // Initialize result    x = x % p;   // Update x if it is more                 // than or equal to p    while (y > 0)    {        // If y is odd, multiply        // x with result        if ((y & 1) > 0)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Function to find modular// inverse of a under modulo p// using Fermat's method.// Assumption: p is primestatic int modInverse(int a, int p){    return power(a, p - 2, p);} // Returns n! % p using// Wilson's Theoremstatic int modFact(int n, int p){    // n! % p is 0 if n >= p    if (p <= n)        return 0;     // Initialize result as (p-1)!    // which is -1 or (p-1)    int res = (p - 1);     // Multiply modulo inverse of    // all numbers from (n+1) to p    for (int i = n + 1; i < p; i++)        res = (res * modInverse(i, p)) % p;    return res;} // Driver Codepublic static void main(String[] args){    int n = 25, p = 29;    System.out.println(modFact(n, p));}} // This code is contributed by mits
def gcdExtended(a,b):    if(b==0):         return a,1,0    g,x1,y1=gcdExtended(b,a%b)     x1,y1 = y1,x1-(a//b)*y1    return g,x1,y1# Driver codefor _ in range(int(input())):     n,m=map(int,input().split())    # if n>m, then there is a  m in (1*2*3..n) % m such that    # m % m=0 then whole ans is 0    if(n>=m):        print(0)    else:        s=1        # Using Wilson's Theorem, (m-1)! % m = m - 1        # Since we need (1*2*3..n) % m        # it can be divided into two parts        # ( ((1*2*3...n) % m) * ((n+1)*(n+2)*...*(m-1)) )%m=m-1        # We only need to calculate 2nd part i.e. let s=((n+1)*(n+2)*...*(m-1)) ) % m        for i in range(n+1,m):            s=(s*i)%m        # Then we divide (m-1) by s under modulo m means modulo inverse of s under m        # It can be done by taking gcd extended        g,a,b=gcdExtended(s,m)        a=a%m        # ans is (m-1)*(modulo inverse of s under m)        print(((m-1)*a)%m)      # This code is contributed by Himanshu Kaithal
// C# program to compute n! % p// using Wilson's Theoremusing System; // Utility function to do modular// exponentiation. It returns (x^y) % pclass GFG{public int power(int x, int y, int p){    int res = 1; // Initialize result    x = x % p; // Update x if it is more               // than or equal to p    while (y > 0)    {        // If y is odd, multiply        // x with result        if((y & 1) > 0)            res = (res * x) % p;         // y must be even now        y = y >> 1; // y = y/2        x = (x * x) % p;    }    return res;} // Function to find modular inverse// of a under modulo p using Fermat's// method. Assumption: p is primepublic int modInverse(int a, int p){    return power(a, p - 2, p);} // Returns n! % p using// Wilson's Theorempublic int modFact(int n, int p){    // n! % p is 0 if n >= p    if (p <= n)        return 0;     // Initialize result as (p-1)!    // which is -1 or (p-1)    int res = (p - 1);     // Multiply modulo inverse of all    // numbers from (n+1) to p    for (int i = n + 1; i < p; i++)        res = (res * modInverse(i, p)) % p;    return res;} // Driver methodpublic static void Main(){    GFG g = new GFG();    int n = 25, p = 29;    Console.WriteLine(g.modFact(n, p));}} // This code is contributed by Soumik
<?php// PHP program to compute// n!% p using Wilson's Theorem // Utility function to do// modular exponentiation.// It returns (x^y) % pfunction power($x, $y, $p){    $res = 1; // Initialize result    $x = $x % $p; // Update x if it is                  // more than or equal to p    while ($y > 0)    {        // If y is odd, multiply        // x with result        if ($y & 1)            $res = ($res * $x) % $p;         // y must be even now        $y = $y >> 1; // y = y/2        $x = ($x * $x) % $p;    }    return $res;} // Function to find modular// inverse of a under modulo// p using Fermat's method.// Assumption: p is primefunction modInverse($a, $p){    return power($a, $p - 2, $p);} // Returns n! % p// using Wilson's Theoremfunction modFact( $n, $p){    // n! % p is 0    // if n >= p    if ($p <= $n)        return 0;     // Initialize result as    // (p-1)! which is -1 or (p-1)    $res = ($p - 1);     // Multiply modulo inverse    // of all numbers from (n+1)    // to p    for ($i = $n + 1; $i < $p; $i++)        $res = ($res *                modInverse($i, $p)) % $p;    return $res;} // Driver Code$n = 25; $p = 29;echo modFact($n, $p); // This code is contributed by ajit?>
<script>    // Javascript program to compute n! % p    // using Wilson's Theorem         // Utility function to do modular    // exponentiation. It returns (x^y) % p    function power(x, y, p)    {        let res = 1; // Initialize result        x = x % p; // Update x if it is more                   // than or equal to p        while (y > 0)        {                     // If y is odd, multiply            // x with result            if((y & 1) > 0)                res = (res * x) % p;             // y must be even now            y = y >> 1; // y = y/2            x = (x * x) % p;        }        return res;    }         // Function to find modular inverse    // of a under modulo p using Fermat's    // method. Assumption: p is prime    function modInverse(a, p)    {        return power(a, p - 2, p);    }         // Returns n! % p using    // Wilson's Theorem    function modFact(n, p)    {             // n! % p is 0 if n >= p        if (p <= n)            return 0;         // Initialize result as (p-1)!        // which is -1 or (p-1)        let res = (p - 1);         // Multiply modulo inverse of all        // numbers from (n+1) to p        for (let i = n + 1; i < p; i++)            res = (res * modInverse(i, p)) % p;        return res;    }         let n = 25, p = 29;    document.write(modFact(n, p));         // This code is contributed by divyeshrabadiya07.</script>
Output: 
5
Time complexity of this method is O((p-n)*Logn)Method 4 (Using Primality Test Algorithm) 
1) Initialize: result = 1
2) While n is not prime
    result = (result * n) % p
3) result = (result * (n-1)) % p  // Using Wilson's Theorem 
4) Return result.
Note that time complexity step 2 of above algorithm depends on the primality test algorithm being used and value of the largest prime smaller than n. The AKS algorithm for example takes O(Log 10.5 n) time. This article is contributed by Ruchir Garg. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
jit_t
vt_m
Mithun Kumar
SoumikMondal
ihritik
Rajput-Ji
princiraj1992
SHUBHAMSINGH10
divyeshrabadiya07
suresh07
himanshu2286200116
rkbhola5
factorial
large-numbers
Modular Arithmetic
number-theory
sieve
Mathematical
number-theory
Mathematical
sieve
Modular Arithmetic
factorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Program to find sum of elements in a given array
Operators in C / C++
Euclidean algorithms (Basic and Extended)
Algorithm to solve Rubik's Cube
The Knight's tour problem | Backtracking-1
Write a program to calculate pow(x,n)
Find minimum number of coins that make a given value
Print all possible combinations of r elements in a given array of size n
Write a program to reverse digits of a number
Fizz Buzz Implementation