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 

Approach:
Let the term be A_N. Therefore, 

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

Now, it is given that A_N 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.
Thus answer N is: 

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

Below is the implementation of above approach:

C++

#include <bits/stdc++.h>
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;
}

C

#include <stdio.h>

// 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
    printf("%d",NearestElement(A, D, P));

    return 0;
}

// This code is contributed by kothavvsaakash.

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

<?php
// Iterative Function to calculate
// (x^y)%p in O(log y) */
function 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 >> 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.
?>

Javascript

<script>

// Javascript Program to Find First
// element in AP which is
// multiple of given prime

// Iterative Function to
// calculate (x^y)%p in
// O(log y) */
function power(x, y, p)
{
    // Initialize result
    let 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
function NearestElement(A, D, P)
{
    // base conditions
    if (A == 0)
        return 0;

    else if (D == 0)
        return -1;

    else
    {
        let X = power(D, P - 2, P);
        return (X * (P - A)) % P;
    }
}

// driver program

    let A = 4, D = 9, P = 11;

    // module both A and D
    A %= P;
    D %= P;

    // function call
    document.write(NearestElement(A, D, P));

</script>

Output:

2

Time Complexity: O(log y)

Auxiliary Space: O(1)