Given two positive integers N and M., The task is to find the smallest divisor D of N such that gcd(D, M) > 1. If there are no such divisors, then print -1.
Examples:
Input: N = 8, M = 10
Output: 2
Input: N = 8, M = 1
Output: -1
A naive approach is to iterate for every factor and calculate the gcd of the factor and M. If it exceeds M, then we have the answer.
Time Complexity: O(N * log max(N, M))
An efficient approach is to iterate till sqrt(n) and check for gcd(i, m). If gcd(i, m) > 1, then we print and break it, else we check for gcd(n/i, m) and store the minimum of them.
Below is the implementation of the above approach.
// C++ implementation of the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum divisor int findMinimum( int n, int m)
{ int mini = m;
// Iterate for all factors of N
for ( int i = 1; i * i <= n; i++) {
if (n % i == 0) {
int sec = n / i;
// Check for gcd > 1
if (__gcd(m, i) > 1) {
return i;
}
// Check for gcd > 1
else if (__gcd(sec, m) > 1) {
mini = min(sec, mini);
}
}
}
// If gcd is m itself
if (mini == m)
return -1;
else
return mini;
} // Drivers code int main()
{ int n = 8, m = 10;
cout << findMinimum(n, m);
return 0;
} |
// Java implementation of the above approach class GFG
{ static int __gcd( int a, int b)
{ if (b == 0 )
return a;
return __gcd(b, a % b);
} // Function to find the minimum divisor static int findMinimum( int n, int m)
{ int mini = m;
// Iterate for all factors of N
for ( int i = 1 ; i * i <= n; i++)
{
if (n % i == 0 )
{
int sec = n / i;
// Check for gcd > 1
if (__gcd(m, i) > 1 )
{
return i;
}
// Check for gcd > 1
else if (__gcd(sec, m) > 1 )
{
mini = Math.min(sec, mini);
}
}
}
// If gcd is m itself
if (mini == m)
return - 1 ;
else
return mini;
} // Driver code public static void main (String[] args)
{ int n = 8 , m = 10 ;
System.out.println(findMinimum(n, m));
} } // This code is contributed by chandan_jnu |
# Python3 implementation of the above approach import math
# Function to find the minimum divisor def findMinimum(n, m):
mini, i = m, 1
# Iterate for all factors of N
while i * i < = n:
if n % i = = 0 :
sec = n / / i
# Check for gcd > 1
if math.gcd(m, i) > 1 :
return i
# Check for gcd > 1
elif math.gcd(sec, m) > 1 :
mini = min (sec, mini)
i + = 1
# If gcd is m itself
if mini = = m:
return - 1
else :
return mini
# Drivers code if __name__ = = "__main__" :
n, m = 8 , 10
print (findMinimum(n, m))
# This code is contributed by Rituraj Jain |
// C# implementation of the above approach using System;
class GFG
{ static int __gcd( int a, int b)
{ if (b == 0)
return a;
return __gcd(b, a % b);
} // Function to find the minimum divisor static int findMinimum( int n, int m)
{ int mini = m;
// Iterate for all factors of N
for ( int i = 1; i * i <= n; i++)
{
if (n % i == 0)
{
int sec = n / i;
// Check for gcd > 1
if (__gcd(m, i) > 1)
{
return i;
}
// Check for gcd > 1
else if (__gcd(sec, m) > 1)
{
mini = Math.Min(sec, mini);
}
}
}
// If gcd is m itself
if (mini == m)
return -1;
else
return mini;
} // Driver code static void Main()
{ int n = 8, m = 10;
Console.WriteLine(findMinimum(n, m));
} } // This code is contributed by chandan_jnu |
<?php // PHP implementation of the above approach function __gcd( $a , $b )
{ if ( $b == 0)
return $a ;
return __gcd( $b , $a % $b );
} // Function to find the minimum divisor function findMinimum( $n , $m )
{ $mini = $m ;
// Iterate for all factors of N
for ( $i = 1; $i * $i <= $n ; $i ++)
{
if ( $n % $i == 0)
{
$sec = $n / $i ;
// Check for gcd > 1
if (__gcd( $m , $i ) > 1)
{
return $i ;
}
// Check for gcd > 1
else if (__gcd( $sec , $m ) > 1)
{
$mini = min( $sec , $mini );
}
}
}
// If gcd is m itself
if ( $mini == $m )
return -1;
else
return $mini ;
} // Driver code $n = 8; $m = 10;
echo (findMinimum( $n , $m ));
// This code is contributed by Code_Mech. |
<script> // javascript implementation of the above approach function __gcd(a , b) {
if (b == 0)
return a;
return __gcd(b, a % b);
}
// Function to find the minimum divisor
function findMinimum(n , m) {
var mini = m;
// Iterate for all factors of N
for ( var i = 1; i * i <= n; i++) {
if (n % i == 0) {
var sec = n / i;
// Check for gcd > 1
if (__gcd(m, i) > 1) {
return i;
}
// Check for gcd > 1
else if (__gcd(sec, m) > 1) {
mini = Math.min(sec, mini);
}
}
}
// If gcd is m itself
if (mini == m)
return -1;
else
return mini;
}
// Driver code
var n = 8, m = 10;
document.write(findMinimum(n, m));
// This code is contributed by todaysgaurav </script> |
2
Time Complexity: O(sqrt(N) * log max(N, M)), as we are using a loop to traverse sqrt(N) times and we are using the inbuilt GCD function in each traversal which costs logN time. Where N and M are the two integers provided.
Auxiliary Space: O(1), as we are not using any extra space.