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

- Add any prime number to
**X**. - 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 = 4Output:1

2 -> 4

Input:X = 5, Y = 6Output:-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 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)**.

- If

Below is the implementation of the above approach:

`// 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 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; `
`} ` |

*chevron_right*

*filter_none*

`// 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 ` |

*chevron_right*

*filter_none*

`# 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 ` |

*chevron_right*

*filter_none*

`// 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 ` |

*chevron_right*

*filter_none*

**Output:**

5

**Time Complexity:** O(1)

## Recommended Posts:

- Number of steps to convert to prime factors
- Minimum prime number operations to convert A to B
- Sum of all the prime numbers with the maximum position of set bit ≤ D
- Maximum no. of contiguous Prime Numbers in an array
- Maximum number of unique prime factors
- Find prime number K in an array such that (A[i] % K) is maximum
- Find sum of a number and its maximum prime factor
- Minimum and Maximum prime numbers in an array
- Queries for maximum difference between prime numbers in given ranges
- Minimum and Maximum Prime Numbers of a Singly Linked List
- Number which has the maximum number of distinct prime factors in the range M to N
- Represent a number as a sum of maximum possible number of Prime Numbers
- Number with maximum number of prime factors
- Convert many to many mappings to maximum no of one to one mappings
- Print the nearest prime number formed by adding prime numbers to N

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.