Friday, January 10, 2025
Google search engine
HomeData Modelling & AIFind First element in AP which is multiple of given prime

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

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments