Skip to content
Related Articles
Open in App
Not now

Related Articles

Maximum prime moves to convert X to Y

Improve Article
Save Article
  • Last Updated : 08 Mar, 2022
Improve Article
Save Article

Given two integers X and Y, the task is to convert X to Y using the following operations: 
 

  1. Add any prime number to X.
  2. Subtract any prime number from Y.

Print the maximum number of such operations required or -1 if it is not possible to convert X to Y.
Examples: 
 

Input: X = 2, Y = 4 
Output:
2 -> 4
Input: X = 5, Y = 6 
Output: -1 
It is impossible to convert 5 to 6 
with the given operations. 

Approach: As the task is to maximize the operations, so the minimum possible value must be added to X in every operation. Since the value has to be prime, so the minimum two primes i.e. 2 and 3 can be used as they both are prime and can cover both even and odd parity. Now, there are three cases: 
 

  • If X > Y then the answer will be -1 as X cannot be made equal to Y with the given operation.
  • If X = Y then the answer will be 0.
  • If X < Y then calculate P = Y – X and, 
    • If P = 1 then the answer will be -1 as 1 is not prime and it cannot be added or subtracted.
    • If P is even then 2 can be repeatedly added to X and the answer will be P / 2
    • If P is even then add 3 to X and then 2 can again be repeatedly added to the new X to make it equal to Y, the result, in this case, will be 1 + ((P – 3) / 2).

Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum operations
// required to convert X to Y
int maxOperations(int X, int Y)
{
 
    // X cannot be converted to Y
    if (X > Y)
        return -1;
 
    int diff = Y - X;
 
    // If the difference is 1
    if (diff == 1)
        return -1;
 
    // If the difference is even
    if (diff % 2 == 0)
        return (diff / 2);
 
    // Add 3 to X and the new
    // difference will be even
    return (1 + ((diff - 3) / 2));
}
 
// Driver code
int main()
{
    int X = 5, Y = 16;
 
    cout << maxOperations(X, Y);
 
    return 0;
}


Java




// Java implementation of the approach
class GFG
{
 
// Function to return the maximum operations
// required to convert X to Y
static int maxOperations(int X, int Y)
{
 
    // X cannot be converted to Y
    if (X > Y)
        return -1;
 
    int diff = Y - X;
 
    // If the difference is 1
    if (diff == 1)
        return -1;
 
    // If the difference is even
    if (diff % 2 == 0)
        return (diff / 2);
 
    // Add 3 to X and the new
    // difference will be even
    return (1 + ((diff - 3) / 2));
}
 
// Driver code
public static void main(String []args)
{
    int X = 5, Y = 16;
 
    System.out.println(maxOperations(X, Y));
}
}
 
// This code is contributed by 29AjayKumar


Python3




# Python3 implementation of the approach
 
# Function to return the maximum operations
# required to convert X to Y
def maxOperations(X, Y) :
 
    # X cannot be converted to Y
    if (X > Y) :
        return -1;
 
    diff = Y - X;
 
    # If the difference is 1
    if (diff == 1) :
        return -1;
 
    # If the difference is even
    if (diff % 2 == 0) :
        return (diff // 2);
 
    # Add 3 to X and the new
    # difference will be even
    return (1 + ((diff - 3) // 2));
 
# Driver code
if __name__ == "__main__" :
 
    X = 5; Y = 16;
 
    print(maxOperations(X, Y));
 
# This code is contributed by AnkitRai01


C#




// C# implementation of the approach
using System;                   
 
class GFG
{
  
// Function to return the maximum operations
// required to convert X to Y
static int maxOperations(int X, int Y)
{
  
    // X cannot be converted to Y
    if (X > Y)
        return -1;
  
    int diff = Y - X;
  
    // If the difference is 1
    if (diff == 1)
        return -1;
  
    // If the difference is even
    if (diff % 2 == 0)
        return (diff / 2);
  
    // Add 3 to X and the new
    // difference will be even
    return (1 + ((diff - 3) / 2));
}
  
// Driver code
public static void Main(String []args)
{
    int X = 5, Y = 16;
  
    Console.WriteLine(maxOperations(X, Y));
}
}
 
// This code is contributed by PrinciRaj1992


Javascript




<script>
 
// JavaScript implementation of the approach
 
// Function to return the maximum operations
// required to convert X to Y
function maxOperations(X, Y)
{
 
    // X cannot be converted to Y
    if (X > Y)
        return -1;
 
    let diff = Y - X;
 
    // If the difference is 1
    if (diff == 1)
        return -1;
 
    // If the difference is even
    if (diff % 2 == 0)
        return (diff / 2);
 
    // Add 3 to X and the new
    // difference will be even
    return (1 + ((diff - 3) / 2));
}
 
// Driver code
 
    let X = 5, Y = 16;
 
    document.write(maxOperations(X, Y));
 
// This code is contributed by _saurabh_jaiswal   
 
</script>


Output: 

5

 

Time Complexity: O(1)

Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!