Given two positive integers A and B, the task is to find the minimum number of increments/decrements required to be performed on either A or B to make both the numbers non-coprime.
Examples:
Input: A = 12, B = 3
Output: 0
Explanation:
As 12 & 3 are already non-coprimes, so the minimum count of increment/decrement operation required is 0.Input: A = 7, B = 17
Output: 2
Approach: The given problem can be solved based on the following observations:
- If A and B have Greatest Common Divisor greater than 1 then no increment or decrement is to be performed, as numbers are already non-coprime.
- Now, check for the difference of 1 in both directions for A as well as B. Hence it requires only a single step to convert any number to an even number.
- If none of the above two cases applies then 2 increments/decrements operations are required to make the numbers A and B to their nearest even number so that the numbers become non-co primes.
Based on the above observations, follow the steps below to solve the problem:
- If the GCD of A and B is not equal to 1, then print 0 as no operation is required.
- Else if the GCD of one of the pair {{A + 1, B}, {A – 1, B}, {A, B + 1}, {A, B – 1}} is not equal to 1, then print 1 as only one operations is required.
- Otherwise, print 2.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum number of // increments/decrements operations required // to make both the numbers non-coprime int makeCoprime( int a, int b)
{ // If a & b are already non-coprimes
if (__gcd(a, b) != 1)
return 0;
// If a & b can become non-coprimes
// by only incrementing/decrementing
// a number only once
if (__gcd(a - 1, b) != 1
or __gcd(a + 1, b) != 1
or __gcd(b - 1, a) != 1
or __gcd(b + 1, a) != 1)
return 1;
// Otherwise
return 2;
} // Driver Code int main()
{ int A = 7, B = 17;
cout << makeCoprime(A, B);
return 0;
} |
// Java program for the above approach public class GFG
{ // function to calculate gcd
static int __gcd( int a, int b)
{
// Everything divides 0
if (a == 0 )
return b;
if (b == 0 )
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return __gcd(a-b, b);
return __gcd(a, b-a);
}
// Function to find the minimum number of
// increments/decrements operations required
// to make both the numbers non-coprime
static int makeCoprime( int a, int b)
{
// If a & b are already non-coprimes
if (__gcd(a, b) != 1 )
return 0 ;
// If a & b can become non-coprimes
// by only incrementing/decrementing
// a number only once
if (__gcd(a - 1 , b) != 1 || __gcd(a + 1 , b) != 1
|| __gcd(b - 1 , a) != 1
|| __gcd(b + 1 , a) != 1 )
return 1 ;
// Otherwise
return 2 ;
}
// Driver code
public static void main(String args[])
{
int A = 7 , B = 17 ;
System.out.println(makeCoprime(A, B));
}
} // This code is contributed by SoumikMondal |
# Python3 program for the above approach from math import gcd
# Function to find the minimum number of # increments/decrements operations required # to make both the numbers non-coprime def makeCoprime(a, b):
# If a & b are already non-coprimes
if (gcd(a, b) ! = 1 ):
return 0
# If a & b can become non-coprimes
# by only incrementing/decrementing
# a number only once
if (gcd(a - 1 , b) ! = 1 or
gcd(a + 1 , b) ! = 1 or
gcd(b - 1 , a) ! = 1 or
gcd(b + 1 , a) ! = 1 ):
return 1
# Otherwise
return 2
# Driver Code if __name__ = = '__main__' :
A = 7
B = 17
print (makeCoprime(A, B))
# This code is contributed by SURENDRA_GANGWAR |
// C# program for the above approach using System;
class GFG{
// Function to calculate gcd static int __gcd( int a, int b)
{ // Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// Base case
if (a == b)
return a;
// a is greater
if (a > b)
return __gcd(a - b, b);
return __gcd(a, b - a);
} // Function to find the minimum number of // increments/decrements operations required // to make both the numbers non-coprime static int makeCoprime( int a, int b)
{ // If a & b are already non-coprimes
if (__gcd(a, b) != 1)
return 0;
// If a & b can become non-coprimes
// by only incrementing/decrementing
// a number only once
if (__gcd(a - 1, b) != 1 ||
__gcd(a + 1, b) != 1 ||
__gcd(b - 1, a) != 1 ||
__gcd(b + 1, a) != 1)
return 1;
// Otherwise
return 2;
} // Driver Code public static void Main(String[] args)
{ int A = 7, B = 17;
Console.Write(makeCoprime(A, B));
} } // This code is contributed by sanjoy_62 |
<script> // JavaScript program for the above approach
function __gcd(a, b) {
if (b == 0)
return a;
return __gcd(b, a % b);
}
// Function to find the minimum number of
// increments/decrements operations required
// to make both the numbers non-coprime
function makeCoprime(a, b) {
// If a & b are already non-coprimes
if (__gcd(a, b) != 1)
return 0;
// If a & b can become non-coprimes
// by only incrementing/decrementing
// a number only once
if (__gcd(a - 1, b) != 1
|| __gcd(a + 1, b) != 1
|| __gcd(b - 1, a) != 1
|| __gcd(b + 1, a) != 1)
return 1;
// Otherwise
return 2;
}
// Driver Code
let A = 7, B = 17;
document.write(makeCoprime(A, B));
// This code is contributed by Potta Lokesh
</script> |
2
Time Complexity: O(log(A, B))
Auxiliary Space: O(1)