Related Articles

# Find remainder when a number A raised to N factorial is divided by P

• Difficulty Level : Hard
• Last Updated : 02 Sep, 2021

Given three integers A, N and P, the task is to find (A^(N!)) % P.

Examples:

Input: A = 2, N = 1, P = 2
Output: 0
Explanation: As (2^(1!)) = 2
Therefore 2 % 2 will be 0.

Input: A = 3, N = 3, P = 2
Output: 1

Naive Approach: The simplest solution of this problem can be find out factorial of N say f, and now calculate A to power f say pow and find its remainder with P.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include ` `using` `namespace` `std;` `// Function to calculate factorial of a Number``long` `long` `int` `fact(``long` `long` `int` `n)``{``    ``long` `long` `int` `ans = 1;` `    ``// Calculating factorial``    ``for` `(``long` `long` `int` `i = 2; i <= n; i++)``        ``ans *= i;` `    ``// Returning factorial``    ``return` `ans;``}` `// Function to calculate resultant remainder``long` `long` `int` `remainder(``    ``long` `long` `int` `n,``    ``long` `long` `int` `a,``    ``long` `long` `int` `p)``{` `    ``// Function call to calculate``    ``// factorial of n``    ``long` `long` `int` `len = fact(n);``    ``long` `long` `int` `ans = 1;` `    ``// Calculating remainder``    ``for` `(``long` `long` `int` `i = 1; i <= len; i++)``        ``ans = (ans * a) % p;` `    ``// Returning resultant remainder``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``long` `long` `int` `A = 2, N = 1, P = 2;` `    ``// Function Call``    ``cout << remainder(N, A, P) << endl;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to calculate factorial``static` `int` `fact(``int` `n)``{``    ``int` `ans = ``1``;` `    ``// Calculating factorial``    ``for` `(``int` `i = ``2``; i <= n; i++)``        ``ans *= i;` `    ``// Returning factorial``    ``return` `ans;``}` `// Function to calculate resultant remainder``static` `int` `remainder(``    ``int` `n,``    ``int` `a,``    ``int` `p)``{` `    ``// Function call to calculate``    ``// factorial of n``    ``int` `len = fact(n);``    ``int` `ans = ``1``;` `    ``// Calculating remainder``    ``for` `(``int` `i = ``1``; i <= len; i++)``        ``ans = (ans * a) % p;` `    ``// Returning resultant remainder``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``  ` `   ``// Given Input``    ``int` `A = ``2``, N = ``1``, P = ``2``;` `    ``// Function Call``    ``System.out.println(remainder(N, A, P));``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python 3 program for above approach` `# Function to calculate factorial of a Number``def` `fact(n):``    ``ans ``=` `1` `    ``# Calculating factorial``    ``for` `i ``in` `range``(``2``,n``+``1``,``1``):``        ``ans ``*``=` `i` `    ``# Returning factorial``    ``return` `ans` `# Function to calculate resultant remainder``def` `remainder(n, a, p):``  ` `    ``# Function call to calculate``    ``# factorial of n``    ``len1 ``=` `fact(n)``    ``ans ``=` `1` `    ``# Calculating remainder``    ``for` `i ``in` `range``(``1``,len1``+``1``,``1``):``        ``ans ``=` `(ans ``*` `a) ``%` `p` `    ``# Returning resultant remainder``    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Given Input``    ``A ``=` `2``    ``N ``=` `1``    ``P ``=` `2` `    ``# Function Call``    ``print``(remainder(N, A, P))``    ` `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG{` `// Function to calculate factorial``static` `int` `fact(``int` `n)``{``    ``int` `ans = 1;` `    ``// Calculating factorial``    ``for` `(``int` `i = 2; i <= n; i++)``        ``ans *= i;` `    ``// Returning factorial``    ``return` `ans;``}` `// Function to calculate resultant remainder``static` `int` `remainder(``    ``int` `n,``    ``int` `a,``    ``int` `p)``{` `    ``// Function call to calculate``    ``// factorial of n``    ``int` `len = fact(n);``    ``int` `ans = 1;` `    ``// Calculating remainder``    ``for` `(``int` `i = 1; i <= len; i++)``        ``ans = (ans * a) % p;` `    ``// Returning resultant remainder``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `Main(``string` `[]args)``{``  ` `   ``// Given Input``    ``int` `A = 2, N = 1, P = 2;` `    ``// Function Call``    ``Console.WriteLine(remainder(N, A, P));``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output:
`0`

Time complexity: O(N!)
Auxiliary Space: O(1)

Efficient Approach: The above can be optimized using concept of modular exponentiation and some properties of modulo and powers:

1. x^(a*b*c) can be written as :- (((x^a)^b)^c) …property of power.

2. ((x^a)^b) % p can be written as :- ((x^a) %p)^b) % p …property of modulo.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include ` `using` `namespace` `std;` `// Function to calculate``// (A^N!)%P in O(log y)``long` `long` `int` `power(``    ``long` `long` `x,``    ``long` `long` `int` `y,``    ``long` `long` `int` `p)``{``    ``// Initialize result``    ``long` `long` `int` `res = 1;` `    ``// Update x if it is more than or``    ``// Equal to p``    ``x = x % p;` `    ``// In case x is divisible by p;``    ``if` `(x == 0)``        ``return` `0;` `    ``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;``        ``x = (x * x) % p;``    ``}` `    ``// Returning modular power``    ``return` `res;``}` `// Function to calculate resultant remainder``long` `long` `int` `remainder(``    ``long` `long` `int` `n,``    ``long` `long` `int` `a,``    ``long` `long` `int` `p)``{` `    ``// Initializing ans``    ``//to store final remainder``  ``long` `long` `int` `ans = a % p;` `    ``// Calculating remainder``    ``for` `(``long` `long` `int` `i = 1; i <= n; i++)``        ``ans = power(ans, i, p);` `    ``// Returning resultant remainder``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``long` `long` `int` `A = 2, N = 1, P = 2;` `    ``// Function Call``    ``cout << remainder(N, A, P) << endl;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``    ``static` `long` `power(``long` `x, ``long` `y, ``long` `p)``    ``{``      ` `        ``// Initialize result``        ``long` `res = ``1``;` `        ``// Update x if it is more than or``        ``// Equal to p``        ``x = x % p;` `        ``// In case x is divisible by p;``        ``if` `(x == ``0``)``            ``return` `0``;` `        ``while` `(y > ``0``)``        ``{``          ` `            ``// If y is odd,``            ``// multiply x with result``            ``if` `((y & ``1``) == ``1``)``                ``res = (res * x) % p;` `            ``// y must be even now``            ``y = y >> ``1``;``            ``x = (x * x) % p;``        ``}` `        ``// Returning modular power``        ``return` `res;``    ``}` `    ``// Function to calculate resultant remainder``    ``static` `long` `remainder(``long` `n, ``long` `a, ``long` `p)``    ``{` `        ``// Initializing ans to store final remainder``        ``long` `ans = a % p;` `        ``// Calculating remainder``        ``for` `(``long` `i = ``1``; i <= n; i++)``            ``ans = power(ans, i, p);` `        ``// Returning resultant remainder``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``      ` `        ``// Given Input``        ``long` `A = ``2``, N = ``1``, P = ``2``;` `        ``// Function Call``        ``System.out.println(remainder(N, A, P));``    ``}``}` `// This code is contributed by maddler.`

## Python3

 `# Python program for above approach` `# Function to calculate``# (A^N!)%P in O(log y)``def` `power(x, y, p):` `    ``# Initialize result``    ``res ``=` `1` `    ``# Update x if it is more than or``    ``# Equal to p``    ``x ``=` `x ``%` `p` `    ``# In case x is divisible by p``    ``if` `(x ``=``=` `0``):``        ``return` `0` `    ``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``        ``x ``=` `(x ``*` `x) ``%` `p``    `  `    ``# Returning modular power``    ``return` `res`  `# Function to calculate resultant remainder``def` `remainder(n, a, p):`  `    ``# Initializing ans``    ``#to store final remainder``    ``ans ``=` `a ``%` `p` `    ``# Calculating remainder``    ``for` `i ``in` `range``(``1``,n``+``1``):``        ``ans ``=` `power(ans, i, p)` `    ``# Returning resultant remainder``    ``return` `ans` `# Driver Code``# Given Input``A ``=` `2``N ``=` `1``P ``=` `2` `# Function Call``print``(remainder(N, A, P))` `# This code is contributed by shivanisinghss2110`

## C#

 `/*package whatever //do not write package name here */``using` `System;` `class` `GFG {``    ``static` `long` `power(``long` `x, ``long` `y, ``long` `p)``    ``{``      ` `        ``// Initialize result``        ``long` `res = 1;` `        ``// Update x if it is more than or``        ``// Equal to p``        ``x = x % p;` `        ``// In case x is divisible by p;``        ``if` `(x == 0)``            ``return` `0;` `        ``while` `(y > 0)``        ``{``          ` `            ``// If y is odd,``            ``// multiply x with result``            ``if` `((y & 1) == 1)``                ``res = (res * x) % p;` `            ``// y must be even now``            ``y = y >> 1;``            ``x = (x * x) % p;``        ``}` `        ``// Returning modular power``        ``return` `res;``    ``}` `    ``// Function to calculate resultant remainder``    ``static` `long` `remainder(``long` `n, ``long` `a, ``long` `p)``    ``{` `        ``// Initializing ans to store final remainder``        ``long` `ans = a % p;` `        ``// Calculating remainder``        ``for` `(``long` `i = 1; i <= n; i++)``            ``ans = power(ans, i, p);` `        ``// Returning resultant remainder``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``      ` `        ``// Given Input``        ``long` `A = 2, N = 1, P = 2;` `        ``// Function Call``        ``Console.Write(remainder(N, A, P));``    ``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output:
`0`

Time complexity: O(N*logN)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up