Related Articles

# Modular multiplicative inverse

• Difficulty Level : Hard
• Last Updated : 22 Jun, 2021

Given two integers ‘a’ and ‘m’, find modular multiplicative inverse of ‘a’ under modulo ‘m’.
The modular multiplicative inverse is an integer ‘x’ such that.

`a x ≅ 1 (mod m)`

The value of x should be in { 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
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 ring {1, 2, ... 10}, so not
valid.

Input:  a = 10, m = 17
Output: 12
Since (10*12) mod 17 = 1, 12 is modulo inverse of 10(under 17).```

Method 1 (Naive)
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 this method.

## 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``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

 `<≅php``// PHP program to find modular``// inverse of a under modulo m` `// A naive method to find modulor``// multiplicative inverse of``// 'a' under modulo 'm'``function` `modInverse( ``\$a``, ``\$m``)``{``    ` `    ``for` `(``\$x` `= 1; ``\$x` `< ``\$m``; ``\$x``++)``        ``if` `(((``\$a``%``\$m``) * (``\$x``%``\$m``)) % ``\$m` `== 1)``            ``return` `\$x``;``}` `    ``// Driver Code``    ``\$a` `= 3;``    ``\$m` `= 11;` `    ``// Function call``    ``echo` `modInverse(``\$a``, ``\$m``);` `// This code is contributed by anuj_67.``≅>`

## Javascript

 ``
Output
`4`

Time Complexity: O(m).

Method 2 (Works when m and a are coprime)
The idea is to use Extended Euclidean algorithms that takes two integers ‘a’ and ‘b’, finds their gcd and also find ‘x’ and ‘y’ such that

`ax + by = gcd(a, b)`

To find multiplicative inverse of ‘a’ under ‘m’, we put b = m in above formula. Since we know that a and m are relatively prime, we can put 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 algorithm.

## 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;``}`

## PHP

 `<≅php``// PHP program to find multiplicative modulo``// inverse using Extended Euclid algorithm.``// Function to find modulo inverse of a``function` `modInverse(``\$a``, ``\$m``)``{``    ``\$x` `= 0;``    ``\$y` `= 0;``    ``\$g` `= gcdExtended(``\$a``, ``\$m``, ``\$x``, ``\$y``);``    ``if` `(``\$g` `!= 1)``        ``echo` `"Inverse doesn't exist"``;``    ``else``    ``{``        ``// m is added to handle negative x``        ``\$res` `= (``\$x` `% ``\$m` `+ ``\$m``) % ``\$m``;``        ``echo` `"Modular multiplicative "` `.``                   ``"inverse is "` `. ``\$res``;``    ``}``}` `// function for extended Euclidean Algorithm``function` `gcdExtended(``\$a``, ``\$b``, &``\$x``, &``\$y``)``{``    ``// Base Case``    ``if` `(``\$a` `== 0)``    ``{``        ``\$x` `= 0;``        ``\$y` `= 1;``        ``return` `\$b``;``    ``}` `    ``\$x1``;``    ``\$y1``; ``// To store results of recursive call``    ``\$gcd` `= gcdExtended(``\$b``%``\$a``, ``\$a``, ``\$x1``, ``\$y1``);` `    ``// Update x and y using results of``    ``// recursive call``    ``\$x` `= ``\$y1` `- (int)(``\$b``/``\$a``) * ``\$x1``;``    ``\$y` `= ``\$x1``;` `    ``return` `\$gcd``;``}` `// Driver Code``\$a` `= 3;``\$m` `= 11;` `// Function call``modInverse(``\$a``, ``\$m``);` `// This code is contributed by chandan_jnu``≅>`
Output
`Modular multiplicative inverse is 4`

Iterative Implementation:

## 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``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

 `<≅php``// Iterative PHP 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``function` `modInverse(``\$a``, ``\$m``)``{``    ``\$m0` `= ``\$m``;``    ``\$y` `= 0;``    ``\$x` `= 1;` `    ``if` `(``\$m` `== 1)``    ``return` `0;` `    ``while` `(``\$a` `> 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\n"``,``                            ``modInverse(``\$a``, ``\$m``);``        ` `// This code is contributed by Anuj_67``≅>`

## Javascript

 ``
Output
`Modular multiplicative inverse is 4`

Time Complexity: O(Log m)

Method 3 (Works when m is prime)
If we know m is prime, then we can also use Fermats’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 idea.

## 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) mode 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``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) mode 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

 `<≅php``// PHP 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``function` `modInverse( ``\$a``, ``\$m``)``{``    ``\$g` `= gcd(``\$a``, ``\$m``);``    ``if` `(``\$g` `!= 1)``        ``echo` `"Inverse doesn't exist"``;``    ``else``    ``{``        ` `        ``// If a and m are relatively``        ``// prime, then modulo inverse``        ``// is a^(m-2) mode m``        ``echo` `"Modular multiplicative inverse is "``                        ``, power(``\$a``, ``\$m` `- 2, ``\$m``);``    ``}``}` `// To compute x^y under modulo m``function` `power( ``\$x``, ``\$y``, ``\$m``)``{``    ``if` `(``\$y` `== 0)``        ``return` `1;``    ``\$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``function` `gcd(``\$a``, ``\$b``)``{``    ``if` `(``\$a` `== 0)``        ``return` `\$b``;``    ``return` `gcd(``\$b` `% ``\$a``, ``\$a``);``}` `// Driver Code``\$a` `= 3;``\$m` `= 11;` `// Function call``modInverse(``\$a``, ``\$m``);``    ` `// This code is contributed by anuj_67.``≅>`

## Javascript

 ``
Output
`Modular multiplicative inverse is 4`

Time Complexity: O(Log m)

We have discussed three methods to find multiplicative inverse modulo m.
1) Naive Method, O(m)
2) Extended Euler’s GCD algorithm, O(Log m) [Works when a and m are coprime]
3) Fermat’s Little theorem, O(Log m) [Works when ‘m’ is prime]

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

References:
https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
http://e-maxx.ru/algo/reverse_element