Skip to content
Related Articles

Related Articles

Improve Article

Maximum prime moves to convert X to Y

  • Last Updated : 15 Sep, 2021

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)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :