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:
 

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

#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 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 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# 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
// 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.
?>

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

2

Time Complexity: O(log y)

Auxiliary Space: O(1)