 Open in App
Not now

# Modular multiplicative inverse

• Difficulty Level : Hard
• Last Updated : 25 Jan, 2023

Given two integers A and M, find the modular multiplicative inverse of A under modulo M.
The modular multiplicative inverse is an integer X such that:

A X ≅ 1 (mod M)

Note: The value of X should be in the range {1, 2, … M-1}, i.e., in the range of integer modulo M. ( Note that X cannot be 0 as A*0 mod M will never be 1). The multiplicative inverse of “A modulo M” exists if and only if A and M are relatively prime (i.e. if gcd(A, M) = 1)

Examples:

Input: A = 3, M = 11
Output: 4
Explanation: Since (4*3) mod 11 = 1, 4 is modulo inverse of 3(under 11).
One might think, 15 also as a valid output as “(15*3) mod 11”
is also 1, but 15 is not in range {1, 2, … 10}, so not valid.

Input:  A = 10, M = 17
Output: 12
Explamation: Since (10*12) mod 17 = 1, 12 is modulo inverse of 10(under 17).

Naive Approach:  To solve the problem, follow the below idea:

A naive method is to try all numbers from 1 to m. For every number x, check if (A * X) % M is 1

Below is the implementation of the above approach:

## C++

 `// C++ program to find modular` `// inverse of A under modulo M` `#include ` `using` `namespace` `std;`   `// A naive method to find modular` `// multiplicative inverse of 'A'` `// under modulo 'M'`   `int` `modInverse(``int` `A, ``int` `M)` `{` `    ``for` `(``int` `X = 1; X < M; X++)` `        ``if` `(((A % M) * (X % M)) % M == 1)` `            ``return` `X;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``cout << modInverse(A, M);` `    ``return` `0;` `}`

## Java

 `// Java program to find modular inverse` `// of A under modulo M` `import` `java.io.*;`   `class` `GFG {`   `    ``// A naive method to find modulor` `    ``// multiplicative inverse of A` `    ``// under modulo M` `    ``static` `int` `modInverse(``int` `A, ``int` `M)` `    ``{`   `        ``for` `(``int` `X = ``1``; X < M; X++)` `            ``if` `(((A % M) * (X % M)) % M == ``1``)` `                ``return` `X;` `        ``return` `1``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `A = ``3``, M = ``11``;`   `        ``// Function call` `        ``System.out.println(modInverse(A, M));` `    ``}` `}`   `/*This code is contributed by Nikita Tiwari.*/`

## Python3

 `# Python3 program to find modular` `# inverse of A under modulo M`   `# A naive method to find modulor` `# multiplicative inverse of A` `# under modulo M`     `def` `modInverse(A, M):`   `    ``for` `X ``in` `range``(``1``, M):` `        ``if` `(((A ``%` `M) ``*` `(X ``%` `M)) ``%` `M ``=``=` `1``):` `            ``return` `X` `    ``return` `-``1`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `3` `    ``M ``=` `11`   `    ``# Function call` `    ``print``(modInverse(A, M))`   `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# program to find modular inverse` `// of A under modulo M` `using` `System;`   `class` `GFG {`   `    ``// A naive method to find modulor` `    ``// multiplicative inverse of A` `    ``// under modulo M` `    ``static` `int` `modInverse(``int` `A, ``int` `M)` `    ``{`   `        ``for` `(``int` `X = 1; X < M; X++)` `            ``if` `(((A % M) * (X % M)) % M == 1)` `                ``return` `X;` `        ``return` `1;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `A = 3, M = 11;`   `        ``// Function call` `        ``Console.WriteLine(modInverse(A, M));` `    ``}` `}`   `// This code is contributed by anuj_67.`

## PHP

 ``

## Javascript

 ``

Output

`4`

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

## Modular multiplicative inverse when M and A are coprime or gcd(A, M)=1:

The idea is to use Extended Euclidean algorithms that take two integers ‘a’ and ‘b’, then find their gcd, and also find ‘x’ and ‘y’ such that

ax + by = gcd(a, b)

To find the multiplicative inverse of ‘A’ under ‘M’, we put b = M in the above formula. Since we know that A and M are relatively prime, we can put the value of gcd as 1.

Ax + My = 1

If we take modulo M on both sides, we get

Ax + My ≅ 1 (mod M)

We can remove the second term on left side as ‘My (mod M)’ would always be 0 for an integer y.

Ax  ≅ 1 (mod M)

So the ‘x’ that we can find using Extended Euclid Algorithm is the multiplicative inverse of ‘A’

Below is the implementation of the above approach:

## C++

 `// C++ program to find multiplicative modulo` `// inverse using Extended Euclid algorithm.` `#include ` `using` `namespace` `std;`   `// Function for extended Euclidean Algorithm` `int` `gcdExtended(``int` `a, ``int` `b, ``int``* x, ``int``* y);`   `// Function to find modulo inverse of a` `void` `modInverse(``int` `A, ``int` `M)` `{` `    ``int` `x, y;` `    ``int` `g = gcdExtended(A, M, &x, &y);` `    ``if` `(g != 1)` `        ``cout << ``"Inverse doesn't exist"``;` `    ``else` `{`   `        ``// m is added to handle negative x` `        ``int` `res = (x % M + M) % M;` `        ``cout << ``"Modular multiplicative inverse is "` `<< res;` `    ``}` `}`   `// Function for extended Euclidean Algorithm` `int` `gcdExtended(``int` `a, ``int` `b, ``int``* x, ``int``* y)` `{`   `    ``// Base Case` `    ``if` `(a == 0) {` `        ``*x = 0, *y = 1;` `        ``return` `b;` `    ``}`   `    ``// To store results of recursive call` `    ``int` `x1, y1;` `    ``int` `gcd = gcdExtended(b % a, a, &x1, &y1);`   `    ``// Update x and y using results of recursive` `    ``// call` `    ``*x = y1 - (b / a) * x1;` `    ``*y = x1;`   `    ``return` `gcd;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``modInverse(A, M);` `    ``return` `0;` `}`   `// This code is contributed by khushboogoyal499`

## C

 `// C program to find multiplicative modulo inverse using` `// Extended Euclid algorithm.` `#include `   `// C function for extended Euclidean Algorithm` `int` `gcdExtended(``int` `a, ``int` `b, ``int``* x, ``int``* y);`   `// Function to find modulo inverse of a` `void` `modInverse(``int` `A, ``int` `M)` `{` `    ``int` `x, y;` `    ``int` `g = gcdExtended(A, M, &x, &y);` `    ``if` `(g != 1)` `        ``printf``(``"Inverse doesn't exist"``);` `    ``else` `{` `        ``// m is added to handle negative x` `        ``int` `res = (x % M + M) % M;` `        ``printf``(``"Modular multiplicative inverse is %d"``, res);` `    ``}` `}`   `// C function for extended Euclidean Algorithm` `int` `gcdExtended(``int` `a, ``int` `b, ``int``* x, ``int``* y)` `{` `    ``// Base Case` `    ``if` `(a == 0) {` `        ``*x = 0, *y = 1;` `        ``return` `b;` `    ``}`   `    ``int` `x1, y1; ``// To store results of recursive call` `    ``int` `gcd = gcdExtended(b % a, a, &x1, &y1);`   `    ``// Update x and y using results of recursive` `    ``// call` `    ``*x = y1 - (b / a) * x1;` `    ``*y = x1;`   `    ``return` `gcd;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``modInverse(A, M);` `    ``return` `0;` `}`

## Java

 `// java program to find multiplicative modulo` `// inverse using Extended Euclid algorithm.` `public` `class` `GFG {`   `    ``// Global Variables` `    ``public` `static` `int` `x;` `    ``public` `static` `int` `y;`   `    ``// Function for extended Euclidean Algorithm` `    ``static` `int` `gcdExtended(``int` `a, ``int` `b)` `    ``{`   `        ``// Base Case` `        ``if` `(a == ``0``) {` `            ``x = ``0``;` `            ``y = ``1``;` `            ``return` `b;` `        ``}`   `        ``// To store results of recursive call` `        ``int` `gcd = gcdExtended(b % a, a);` `        ``int` `x1 = x;` `        ``int` `y1 = y;`   `        ``// Update x and y using results of recursive` `        ``// call` `        ``int` `tmp = b / a;` `        ``x = y1 - tmp * x1;` `        ``y = x1;`   `        ``return` `gcd;` `    ``}`   `    ``static` `void` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `g = gcdExtended(A, M);` `        ``if` `(g != ``1``) {` `            ``System.out.println(``"Inverse doesn't exist"``);` `        ``}` `        ``else` `{`   `            ``// m is added to handle negative x` `            ``int` `res = (x % M + M) % M;` `            ``System.out.println(` `                ``"Modular multiplicative inverse is "` `+ res);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `A = ``3``, M = ``11``;`   `        ``// Function Call` `        ``modInverse(A, M);` `    ``}` `}`   `// The code is contributed by Gautam goel (gautamgoel962)`

## Python3

 `# Python3 program to find multiplicative modulo` `# inverse using Extended Euclid algorithm.`   `# Global Variables` `x, y ``=` `0``, ``1`   `# Function for extended Euclidean Algorithm`     `def` `gcdExtended(a, b):` `    ``global` `x, y`   `    ``# Base Case` `    ``if` `(a ``=``=` `0``):` `        ``x ``=` `0` `        ``y ``=` `1` `        ``return` `b`   `    ``# To store results of recursive call` `    ``gcd ``=` `gcdExtended(b ``%` `a, a)` `    ``x1 ``=` `x` `    ``y1 ``=` `y`   `    ``# Update x and y using results of recursive` `    ``# call` `    ``x ``=` `y1 ``-` `(b ``/``/` `a) ``*` `x1` `    ``y ``=` `x1`   `    ``return` `gcd`     `def` `modInverse(A, M):`   `    ``g ``=` `gcdExtended(A, M)` `    ``if` `(g !``=` `1``):` `        ``print``(``"Inverse doesn't exist"``)`   `    ``else``:`   `        ``# m is added to handle negative x` `        ``res ``=` `(x ``%` `M ``+` `M) ``%` `M` `        ``print``(``"Modular multiplicative inverse is "``, res)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `3` `    ``M ``=` `11`   `    ``# Function call` `    ``modInverse(A, M)`     `# This code is contributed by phasing17`

## C#

 `// C# program to find multiplicative modulo` `// inverse using Extended Euclid algorithm.`   `using` `System;`   `public` `class` `GFG {` `    ``public` `static` `int` `x, y;`   `    ``// Function for extended Euclidean Algorithm` `    ``static` `int` `gcdExtended(``int` `a, ``int` `b)` `    ``{`   `        ``// Base Case` `        ``if` `(a == 0) {` `            ``x = 0;` `            ``y = 1;` `            ``return` `b;` `        ``}`   `        ``// To store results of recursive call` `        ``int` `gcd = gcdExtended(b % a, a);` `        ``int` `x1 = x;` `        ``int` `y1 = y;`   `        ``// Update x and y using results of recursive` `        ``// call` `        ``x = y1 - (b / a) * x1;` `        ``y = x1;`   `        ``return` `gcd;` `    ``}`   `    ``// Function to find modulo inverse of a` `    ``static` `void` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `g = gcdExtended(A, M);` `        ``if` `(g != 1)` `            ``Console.Write(``"Inverse doesn't exist"``);` `        ``else` `{`   `            ``// M is added to handle negative x` `            ``int` `res = (x % M + M) % M;` `            ``Console.Write(` `                ``"Modular multiplicative inverse is "` `+ res);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `A = 3, M = 11;`   `        ``// Function call` `        ``modInverse(A, M);` `    ``}` `}`   `// this code is contributed by phasing17`

## PHP

 ``

## Javascript

 ``

Output

`Modular multiplicative inverse is 4`

Time Complexity: O(log M)
Auxiliary Space: O(log M), because of the internal recursion stack.

Iterative Implementation of the above approach:

## C++

 `// Iterative C++ program to find modular` `// inverse using extended Euclid algorithm`   `#include ` `using` `namespace` `std;`   `// Returns modulo inverse of a with respect` `// to m using extended Euclid Algorithm` `// Assumption: a and m are coprimes, i.e.,` `// gcd(A, M) = 1` `int` `modInverse(``int` `A, ``int` `M)` `{` `    ``int` `m0 = M;` `    ``int` `y = 0, x = 1;`   `    ``if` `(M == 1)` `        ``return` `0;`   `    ``while` `(A > 1) {` `        ``// q is quotient` `        ``int` `q = A / M;` `        ``int` `t = M;`   `        ``// m is remainder now, process same as` `        ``// Euclid's algo` `        ``M = A % M, A = t;` `        ``t = y;`   `        ``// Update y and x` `        ``y = x - q * y;` `        ``x = t;` `    ``}`   `    ``// Make x positive` `    ``if` `(x < 0)` `        ``x += m0;`   `    ``return` `x;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``cout << ``"Modular multiplicative inverse is "` `         ``<< modInverse(A, M);` `    ``return` `0;` `}` `// this code is contributed by shivanisinghss2110`

## C

 `// Iterative C program to find modular` `// inverse using extended Euclid algorithm`   `#include `   `// Returns modulo inverse of a with respect` `// to m using extended Euclid Algorithm` `// Assumption: a and m are coprimes, i.e.,` `// gcd(A, M) = 1` `int` `modInverse(``int` `A, ``int` `M)` `{` `    ``int` `m0 = M;` `    ``int` `y = 0, x = 1;`   `    ``if` `(M == 1)` `        ``return` `0;`   `    ``while` `(A > 1) {` `        ``// q is quotient` `        ``int` `q = A / M;` `        ``int` `t = M;`   `        ``// m is remainder now, process same as` `        ``// Euclid's algo` `        ``M = A % M, A = t;` `        ``t = y;`   `        ``// Update y and x` `        ``y = x - q * y;` `        ``x = t;` `    ``}`   `    ``// Make x positive` `    ``if` `(x < 0)` `        ``x += m0;`   `    ``return` `x;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``printf``(``"Modular multiplicative inverse is %d\n"``,` `           ``modInverse(A, M));` `    ``return` `0;` `}`

## Java

 `// Iterative Java program to find modular` `// inverse using extended Euclid algorithm`   `class` `GFG {`   `    ``// Returns modulo inverse of a with` `    ``// respect to m using extended Euclid` `    ``// Algorithm Assumption: a and m are` `    ``// coprimes, i.e., gcd(A, M) = 1` `    ``static` `int` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `m0 = M;` `        ``int` `y = ``0``, x = ``1``;`   `        ``if` `(M == ``1``)` `            ``return` `0``;`   `        ``while` `(A > ``1``) {` `            ``// q is quotient` `            ``int` `q = A / M;`   `            ``int` `t = M;`   `            ``// m is remainder now, process` `            ``// same as Euclid's algo` `            ``M = A % M;` `            ``A = t;` `            ``t = y;`   `            ``// Update x and y` `            ``y = x - q * y;` `            ``x = t;` `        ``}`   `        ``// Make x positive` `        ``if` `(x < ``0``)` `            ``x += m0;`   `        ``return` `x;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `A = ``3``, M = ``11``;`   `        ``// Function call` `        ``System.out.println(``"Modular multiplicative "` `                           ``+ ``"inverse is "` `                           ``+ modInverse(A, M));` `    ``}` `}`   `/*This code is contributed by Nikita Tiwari.*/`

## Python3

 `# Iterative Python 3 program to find` `# modular inverse using extended` `# Euclid algorithm`   `# Returns modulo inverse of a with` `# respect to m using extended Euclid` `# Algorithm Assumption: a and m are` `# coprimes, i.e., gcd(A, M) = 1`     `def` `modInverse(A, M):` `    ``m0 ``=` `M` `    ``y ``=` `0` `    ``x ``=` `1`   `    ``if` `(M ``=``=` `1``):` `        ``return` `0`   `    ``while` `(A > ``1``):`   `        ``# q is quotient` `        ``q ``=` `A ``/``/` `M`   `        ``t ``=` `M`   `        ``# m is remainder now, process` `        ``# same as Euclid's algo` `        ``M ``=` `A ``%` `M` `        ``A ``=` `t` `        ``t ``=` `y`   `        ``# Update x and y` `        ``y ``=` `x ``-` `q ``*` `y` `        ``x ``=` `t`   `    ``# Make x positive` `    ``if` `(x < ``0``):` `        ``x ``=` `x ``+` `m0`   `    ``return` `x`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `3` `    ``M ``=` `11`   `    ``# Function call` `    ``print``(``"Modular multiplicative inverse is"``,` `          ``modInverse(A, M))`   `# This code is contributed by Nikita tiwari.`

## C#

 `// Iterative C# program to find modular` `// inverse using extended Euclid algorithm` `using` `System;` `class` `GFG {`   `    ``// Returns modulo inverse of a with` `    ``// respect to m using extended Euclid` `    ``// Algorithm Assumption: a and m are` `    ``// coprimes, i.e., gcd(A, M) = 1` `    ``static` `int` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `m0 = M;` `        ``int` `y = 0, x = 1;`   `        ``if` `(M == 1)` `            ``return` `0;`   `        ``while` `(A > 1) {` `            ``// q is quotient` `            ``int` `q = A / M;`   `            ``int` `t = M;`   `            ``// m is remainder now, process` `            ``// same as Euclid's algo` `            ``M = A % M;` `            ``A = t;` `            ``t = y;`   `            ``// Update x and y` `            ``y = x - q * y;` `            ``x = t;` `        ``}`   `        ``// Make x positive` `        ``if` `(x < 0)` `            ``x += m0;`   `        ``return` `x;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `A = 3, M = 11;`   `        ``// Function call` `        ``Console.WriteLine(``"Modular multiplicative "` `                          ``+ ``"inverse is "` `                          ``+ modInverse(A, M));` `    ``}` `}`   `// This code is contributed by anuj_67.`

## PHP

 ` 1)` `    ``{` `        `  `        ``// q is quotient` `        ``\$q` `= (int) (``\$A` `/ ``\$M``);` `        ``\$t` `= ``\$M``;`   `        ``// m is remainder now,` `        ``// process same as` `        ``// Euclid's algo` `        ``\$M` `= ``\$A` `% ``\$M``;` `        ``\$A` `= ``\$t``;` `        ``\$t` `= ``\$y``;`   `        ``// Update y and x` `        ``\$y` `= ``\$x` `- ``\$q` `* ``\$y``;` `        ``\$x` `= ``\$t``;` `    ``}`   `    ``// Make x positive` `    ``if` `(``\$x` `< 0)` `    ``\$x` `+= ``\$m0``;`   `    ``return` `\$x``;` `}`   `    ``// Driver Code` `    ``\$A` `= 3;` `    ``\$M` `= 11;`   `    ``// Function call` `    ``echo` `"Modular multiplicative inverse is: "``,` `                            ``modInverse(``\$A``, ``\$M``);` `        `  `// This code is contributed by Anuj_67` `?>`

## Javascript

 ``

Output

`Modular multiplicative inverse is 4`

Time Complexity: O(log m)
Auxiliary Space: O(1)

## Modular multiplicative inverse when M is prime:

If we know M is prime, then we can also use Fermat’s little theorem to find the inverse.

aM-1 ≅ 1 (mod M)

If we multiply both sides with a-1, we get

a-1 ≅ a M-2 (mod M)

Below is the implementation of the above approach:

## C++

 `// C++ program to find modular inverse of A under modulo M` `// This program works only if M is prime.` `#include ` `using` `namespace` `std;`   `// To find GCD of a and b` `int` `gcd(``int` `a, ``int` `b);`   `// To compute x raised to power y under modulo M` `int` `power(``int` `x, unsigned ``int` `y, unsigned ``int` `M);`   `// Function to find modular inverse of a under modulo M` `// Assumption: M is prime` `void` `modInverse(``int` `A, ``int` `M)` `{` `    ``int` `g = gcd(A, M);` `    ``if` `(g != 1)` `        ``cout << ``"Inverse doesn't exist"``;` `    ``else` `{` `        ``// If a and m are relatively prime, then modulo` `        ``// inverse is a^(m-2) mode m` `        ``cout << ``"Modular multiplicative inverse is "` `             ``<< power(A, M - 2, M);` `    ``}` `}`   `// To compute x^y under modulo m` `int` `power(``int` `x, unsigned ``int` `y, unsigned ``int` `M)` `{` `    ``if` `(y == 0)` `        ``return` `1;`   `    ``int` `p = power(x, y / 2, M) % M;` `    ``p = (p * p) % M;`   `    ``return` `(y % 2 == 0) ? p : (x * p) % M;` `}`   `// Function to return gcd of a and b` `int` `gcd(``int` `a, ``int` `b)` `{` `    ``if` `(a == 0)` `        ``return` `b;` `    ``return` `gcd(b % a, a);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `A = 3, M = 11;`   `    ``// Function call` `    ``modInverse(A, M);` `    ``return` `0;` `}`

## Java

 `// Java program to find modular` `// inverse of A under modulo M` `// This program works only if` `// M is prime.` `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to find modular inverse of a` `    ``// under modulo M Assumption: M is prime` `    ``static` `void` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `g = gcd(A, M);` `        ``if` `(g != ``1``)` `            ``System.out.println(``"Inverse doesn't exist"``);` `        ``else` `{` `            ``// If a and m are relatively prime, then modulo` `            ``// inverse is a^(m-2) mode m` `            ``System.out.println(` `                ``"Modular multiplicative inverse is "` `                ``+ power(A, M - ``2``, M));` `        ``}` `    ``}`   `    ``static` `int` `power(``int` `x, ``int` `y, ``int` `M)` `    ``{` `        ``if` `(y == ``0``)` `            ``return` `1``;` `        ``int` `p = power(x, y / ``2``, M) % M;` `        ``p = (``int``)((p * (``long``)p) % M);` `        ``if` `(y % ``2` `== ``0``)` `            ``return` `p;` `        ``else` `            ``return` `(``int``)((x * (``long``)p) % M);` `    ``}`   `    ``// Function to return gcd of a and b` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``if` `(a == ``0``)` `            ``return` `b;` `        ``return` `gcd(b % a, a);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `A = ``3``, M = ``11``;`   `        ``// Function call` `        ``modInverse(A, M);` `    ``}` `}`   `// This code is contributed by Nikita Tiwari.`

## Python3

 `# Python3 program to find modular` `# inverse of A under modulo M`   `# This program works only if M is prime.`   `# Function to find modular` `# inverse of A under modulo M` `# Assumption: M is prime`     `def` `modInverse(A, M):`   `    ``g ``=` `gcd(A, M)`   `    ``if` `(g !``=` `1``):` `        ``print``(``"Inverse doesn't exist"``)`   `    ``else``:`   `        ``# If A and M are relatively prime,` `        ``# then modulo inverse is A^(M-2) mod M` `        ``print``(``"Modular multiplicative inverse is "``,` `              ``power(A, M ``-` `2``, M))`   `# To compute x^y under modulo M`     `def` `power(x, y, M):`   `    ``if` `(y ``=``=` `0``):` `        ``return` `1`   `    ``p ``=` `power(x, y ``/``/` `2``, M) ``%` `M` `    ``p ``=` `(p ``*` `p) ``%` `M`   `    ``if``(y ``%` `2` `=``=` `0``):` `        ``return` `p` `    ``else``:` `        ``return` `((x ``*` `p) ``%` `M)`   `# Function to return gcd of a and b`     `def` `gcd(a, b):` `    ``if` `(a ``=``=` `0``):` `        ``return` `b`   `    ``return` `gcd(b ``%` `a, a)`     `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``A ``=` `3` `    ``M ``=` `11`   `    ``# Function call` `    ``modInverse(A, M)`     `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# program to find modular` `// inverse of a under modulo M` `// This program works only if` `// M is prime.` `using` `System;` `class` `GFG {`   `    ``// Function to find modular` `    ``// inverse of A under modulo` `    ``// M Assumption: M is prime` `    ``static` `void` `modInverse(``int` `A, ``int` `M)` `    ``{` `        ``int` `g = gcd(A, M);` `        ``if` `(g != 1)` `            ``Console.Write(``"Inverse doesn't exist"``);` `        ``else` `{` `            ``// If A and M are relatively` `            ``// prime, then modulo inverse` `            ``// is A^(M-2) mod M` `            ``Console.Write(` `                ``"Modular multiplicative inverse is "` `                ``+ power(A, M - 2, M));` `        ``}` `    ``}`   `    ``// To compute x^y under` `    ``// modulo M` `    ``static` `int` `power(``int` `x, ``int` `y, ``int` `M)` `    ``{` `        ``if` `(y == 0)` `            ``return` `1;`   `        ``int` `p = power(x, y / 2, M) % M;` `        ``p = (p * p) % M;`   `        ``if` `(y % 2 == 0)` `            ``return` `p;` `        ``else` `            ``return` `(x * p) % M;` `    ``}`   `    ``// Function to return` `    ``// gcd of a and b` `    ``static` `int` `gcd(``int` `a, ``int` `b)` `    ``{` `        ``if` `(a == 0)` `            ``return` `b;` `        ``return` `gcd(b % a, a);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `A = 3, M = 11;`   `        ``// Function call` `        ``modInverse(A, M);` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Modular multiplicative inverse is 4`

Time Complexity: O(log M)
Auxiliary Space: O(log M), because of the internal recursion stack.

Applications:
Computation of the modular multiplicative inverse is an essential step in RSA public-key encryption method.