Multiplicative order

In number theory, given an integer A and a positive integer N with gcd( A , N) = 1, the multiplicative order of a modulo N is the smallest positive integer k with A^k( mod N ) = 1. ( 0 < K < N )

Examples:

```Input : A = 4 , N = 7
Output : 3
explanation :  GCD(4, 7) = 1
A^k( mod N ) = 1 ( smallest positive integer K )
4^1 = 4(mod 7)  = 4
4^2 = 16(mod 7) = 2
4^3 = 64(mod 7)  = 1
4^4 = 256(mod 7) = 4
4^5 = 1024(mod 7)  = 2
4^6 = 4096(mod 7)  = 1

smallest positive integer K = 3

Input :  A = 3 , N = 1000
Output : 100  (3^100 (mod 1000) == 1)

Input : A = 4 , N = 11
Output : 5
```

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

IF we take a close look then we observe that we do not need to calculate power every time. we can be obtaining next power by multiplying ‘A’ with the previous result of a module .

```Explanation :
A = 4 , N = 11
initially result = 1
with normal                with modular arithmetic (A * result)
4^1 = 4 (mod 11 ) = 4  ||  4 * 1 = 4 (mod 11 ) = 4 [ result = 4]
4^2 = 16(mod 11 ) = 5  ||  4 * 4 = 16(mod 11 ) = 5 [ result = 5]
4^3 = 64(mod 11 ) = 9  ||  4 * 5 = 20(mod 11 ) = 9 [ result = 9]
4^4 = 256(mod 11 )= 3  ||  4 * 9 = 36(mod 11 ) = 3 [ result = 3]
4^5 = 1024(mod 5 ) = 1 ||  4 * 3 = 12(mod 11 ) = 1 [ result = 1]

smallest positive integer  5
```

Run a loop from 1 to N-1 and Return the smallest +ve power of A under modulo n which is equal to 1.

Below C++ implementation of above idea.

```// C++ program to implement multiplicative order
#include<bits/stdc++.h>
using namespace std;

// fuction for GCD
int GCD ( int a , int b )
{
if (b == 0 )
return a;
return GCD( b , a%b ) ;
}

// Fucnction return smallest +ve integer that
// holds condition A^k(mod N ) = 1
int multiplicativeOrder(int A, int  N)
{
if (GCD(A, N ) != 1)
return -1;

// result store power of A that rised to
// the power N-1
unsigned int result = 1;

int K = 1 ;
while (K < N)
{
// modular arithmetic
result = (result * A) % N ;

// return samllest +ve integer
if (result  == 1)
return K;

// increment power
K++;
}

return -1 ;
}

//driver program to test above function
int main()
{
int A = 4 , N = 7;
cout << multiplicativeOrder(A, N);
return 0;
}
```

Output:

```3
```

Time Complexity: O(N)

Reference : https://en.wikipedia.org/wiki/Multiplicative_order
This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

GATE CS Corner    Company Wise Coding Practice

3.5 Average Difficulty : 3.5/5.0
Based on 4 vote(s)