# Find First element in AP which is multiple of given prime

Given the first term (A) and common difference (D) of an Arithmetic Progression, and a prime number (P). The task is to find the position of the first element in the given AP which is a multiple of the given prime number P.

Examples:

Input: A = 4, D = 9, P = 11
Output: 2
Explanation :
The third term of the given AP is
a multiple of prime number 11.
First Term = 4
Second Term = 4+9 = 13
Third Term = 4+2*9 = 22

Input: A = 5, D = 6, P = 7
Output: 5
Explanation :
The sixth term of the given AP is
a multiple of prime number 7.
First Term = 5
Second Term = 5+6 = 11
Third Term = 5+2*6 = 17
Fourth Term = 5+3*6 = 23
Fifth Term = 5+4*6 = 29
Sixth Term = 5+5*5 = 35

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

Approach:

Let the term be AN. Therefore,

`AN = (A + (N-1)*D)`

Now, it is given that AN is a multiple of P. Then,

```A + (N-1)*D = k*P

Where, k is a constant.
```

Now let A be (A % P) and D be (D % P). So, we have (N-1)*D = (k*P – A).

Adding and subtracting P on RHS, we get:

```(N-1)*D = P(k-1) + (P-A),

Where P-A is a non-negative number
(since A is replaced by A%P which is less than P)
```

Finally taking mod on both sides:

```     ((N-1)*D)%P = (P-A)%P
or, ((N-1)D)%P = P-A
```

Lets find a X < P, such that (D*X)%P = 1. This X is known as the inverse modulo of D with respect to P.

```((X*(P-A)) % P) + 1.
```

Below is the implementation of above approach:

## C++

 `#include ` `using` `namespace` `std; ` ` `  `// Iterative Function to calculate  ` `// (x^y)%p in O(log y) */ ` `int` `power(``int` `x, ``int` `y, ``int` `p) ` `{ ` `    ``// Initialize result ` `    ``int` `res = 1;  ` ` `  `    ``// Update x if it is more than or ` `    ``// equal to p ` `    ``x = x % 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 nearest element in common ` `int` `NearestElement(``int` `A, ``int` `D, ``int` `P) ` `{ ` `    ``// base conditions ` `    ``if` `(A == 0) ` `        ``return` `0; ` ` `  `    ``else` `if` `(D == 0) ` `        ``return` `-1; ` ` `  `    ``else` `{ ` `        ``int` `X = power(D, P - 2, P); ` `        ``return` `(X * (P - A)) % P; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A = 4, D = 9, P = 11; ` ` `  `    ``// module both A and D ` `    ``A %= P; ` `    ``D %= P; ` ` `  `    ``// function call ` `    ``cout << NearestElement(A, D, P); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java Program to Find First ` `// element in AP which is  ` `// multiple of given prime ` `class` `GFG ` `{ ` `// Iterative Function to  ` `// calculate (x^y)%p in ` `// O(log y) */ ` `static` `int` `power(``int` `x,  ` `                 ``int` `y, ``int` `p) ` `{ ` `    ``// Initialize result ` `    ``int` `res = ``1``;  ` ` `  `    ``// Update x if it is  ` `    ``// more than or equal to p ` `    ``x = x % 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 nearest ` `// element in common ` `static` `int` `NearestElement(``int` `A,  ` `                          ``int` `D, ``int` `P) ` `{ ` `    ``// base conditions ` `    ``if` `(A == ``0``) ` `        ``return` `0``; ` ` `  `    ``else` `if` `(D == ``0``) ` `        ``return` `-``1``; ` ` `  `    ``else` `    ``{ ` `        ``int` `X = power(D, P - ``2``, P); ` `        ``return` `(X * (P - A)) % P; ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `A = ``4``, D = ``9``, P = ``11``; ` ` `  `    ``// module both A and D ` `    ``A %= P; ` `    ``D %= P; ` ` `  `    ``// function call ` `    ``System.out.println(NearestElement(A, D, P)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by Arnab Kundu `

## Python 3

 `# Python 3 Program to Find First  ` `# element in AP which is   ` `# multiple of given prime ` ` `  `# Iterative Function to calculate   ` `# (x^y)%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 ` ` `  `    ``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/2  ` `        ``y ``=` `y >> ``1` `        ``x ``=` `(x ``*` `x) ``%` `p ` ` `  `    ``return` `res ` ` `  `# function to find nearest element in common ` `def` `NearestElement(A, D, P) : ` ` `  `    ``# base conditions  ` `    ``if` `A ``=``=` `0` `: ` `        ``return` `0` ` `  `    ``elif` `D ``=``=` `0` `: ` `        ``return` `-``1` ` `  `    ``else` `: ` `        ``X ``=` `power(D, P ``-` `2``, P) ` `        ``return` `(X ``*` `(P ``-` `A)) ``%` `P ` `     `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: ` `     `  `    ``A, D, P ``=` `4``, ``9``, ``11` ` `  `    ``# module both A and D  ` `    ``A ``%``=` `P ` `    ``D ``%``=` `P ` ` `  `    ``# function call ` `    ``print``(NearestElement(A, D, P)) ` `     `  `# This code is contributed by ANKITRAI1 `

## C#

 `// C# Program to Find First ` `// element in AP which is  ` `// multiple of given prime ` `using` `System; ` ` `  `class` `GFG ` `{ ` `// Iterative Function to  ` `// calculate (x^y)%p in ` `// O(log y) */ ` `static` `int` `power(``int` `x,  ` `                 ``int` `y, ``int` `p) ` `{ ` `    ``// Initialize result ` `    ``int` `res = 1;  ` ` `  `    ``// Update x if it is  ` `    ``// more than or equal to p ` `    ``x = x % 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 nearest ` `// element in common ` `static` `int` `NearestElement(``int` `A,  ` `                          ``int` `D, ``int` `P) ` `{ ` `    ``// base conditions ` `    ``if` `(A == 0) ` `        ``return` `0; ` ` `  `    ``else` `if` `(D == 0) ` `        ``return` `-1; ` ` `  `    ``else` `    ``{ ` `        ``int` `X = power(D, P - 2, P); ` `        ``return` `(X * (P - A)) % P; ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `A = 4, D = 9, P = 11; ` ` `  `    ``// module both A and D ` `    ``A %= P; ` `    ``D %= P; ` ` `  `    ``// function call ` `    ``Console.WriteLine(NearestElement(A, D, P)); ` `} ` `} ` ` `  `// This code is contributed  ` `// by chandan_jnu. `

## PHP

 ` 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 nearest ` `// element in common ` `function` `NearestElement(``\$A``, ``\$D``, ``\$P``) ` `{ ` `    ``// base conditions ` `    ``if` `(``\$A` `== 0) ` `        ``return` `0; ` ` `  `    ``else` `if` `(``\$D` `== 0) ` `        ``return` `-1; ` ` `  `    ``else`  `    ``{ ` `        ``\$X` `= power(``\$D``, ``\$P` `- 2, ``\$P``); ` `        ``return` `(``\$X` `* (``\$P` `- ``\$A``)) %``\$P``; ` `    ``} ` `} ` ` `  `// Driver code ` `\$A` `= 4; ``\$D` `= 9; ``\$P` `= 11; ` ` `  `// module both A and D ` `\$A` `%= ``\$P``; ` `\$D` `%= ``\$P``; ` ` `  `// function call ` `echo` `NearestElement(``\$A``, ``\$D``, ``\$P``); ` ` `  `// This code is contributed  ` `// by chandan_jnu. ` `?> `

Output:

```2
```

My Personal Notes arrow_drop_up

pawanasipugmailcom

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.