# Maximum prime moves to convert X to Y

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: 1
2 -> 4

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 repetedly 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 ` `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 differecne 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 differecne 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 differecne 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 differecne 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 `

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.