Given a point **(x, y)**, the task is to check if it is possible to reach from origin to **(x, y)** in exactly **Z** steps. From a given point **(x, y)** we can only moves in four direction left**(x – 1, y)**, right**(x + 1, y)**, up**(x, y + 1)** and down**(x, y – 1)**.**Examples:**

Input:x = 5, y = 5, z = 11Output:Not PossibleInput:x = 10, y = 15, z = 25Output:Possible

**Approach:**

- The shortest path from origin to
**(x, y)**, is**|x|+|y|**. - So, it is clear that if
**Z**less than**|x|+|y|**, then we can’t reach**(x, y)**from origin in exactly**Z**steps. - If the number of steps is not less than
**|x|+|y|**then, we have to check below two conditions to check if we can reach to**(x, y)**or not:- If
**Z ≥ |x| + |y|**, and - If
**(Z – |x| + |y|)%2**is**0**.

- If
- For the second conditions in the above step, if we reach
**(x, y)**, we can take two more steps such as**(x, y)–>(x, y+1)–>(x, y)**to come back to the same position**(x, y)**. And this is possible only if different between them is even.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if it is possible to` `// reach (x, y) from origin in exactly z steps` `void` `possibleToReach(` `int` `x, ` `int` `y, ` `int` `z)` `{` ` ` `// Condition if we can't reach in Z steps` ` ` `if` `(z < ` `abs` `(x) + ` `abs` `(y)` ` ` `|| (z - ` `abs` `(x) - ` `abs` `(y)) % 2) {` ` ` `cout << ` `"Not Possible"` `<< endl;` ` ` `}` ` ` `else` ` ` `cout << ` `"Possible"` `<< endl;` `}` `// Driver Code` `int` `main()` `{` ` ` `// Destination point coordinate` ` ` `int` `x = 5, y = 5;` ` ` `// Number of steps allowed` ` ` `int` `z = 11;` ` ` `// Function Call` ` ` `possibleToReach(x, y, z);` ` ` `return` `0;` `}` |

## Java

`// Java program for the above approach` `class` `GFG{` `// Function to check if it is possible` `// to reach (x, y) from origin in` `// exactly z steps` `static` `void` `possibleToReach(` `int` `x, ` `int` `y, ` `int` `z)` `{` ` ` ` ` `// Condition if we can't reach in Z steps` ` ` `if` `(z < Math.abs(x) + Math.abs(y) ||` ` ` `(z - Math.abs(x) - Math.abs(y)) % ` `2` `== ` `1` `)` ` ` `{` ` ` `System.out.print(` `"Not Possible"` `+ ` `"\n"` `);` ` ` `}` ` ` `else` ` ` `System.out.print(` `"Possible"` `+ ` `"\n"` `);` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` ` ` `// Destination point coordinate` ` ` `int` `x = ` `5` `, y = ` `5` `;` ` ` `// Number of steps allowed` ` ` `int` `z = ` `11` `;` ` ` `// Function Call` ` ` `possibleToReach(x, y, z);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python3 program for the above approach` `# Function to check if it is possible to` `# reach (x, y) from origin in exactly z steps` `def` `possibleToReach(x, y, z):` ` ` `#Condition if we can't reach in Z steps` ` ` `if` `(z < ` `abs` `(x) ` `+` `abs` `(y) ` `or` ` ` `(z ` `-` `abs` `(x) ` `-` `abs` `(y)) ` `%` `2` `):` ` ` `print` `(` `"Not Possible"` `)` ` ` `else` `:` ` ` `print` `(` `"Possible"` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Destination pocoordinate` ` ` `x ` `=` `5` ` ` `y ` `=` `5` ` ` `# Number of steps allowed` ` ` `z ` `=` `11` ` ` `# Function call` ` ` `possibleToReach(x, y, z)` `# This code is contributed by mohit kumar 29` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` `// Function to check if it is possible` `// to reach (x, y) from origin in` `// exactly z steps` `static` `void` `possibleToReach(` `int` `x, ` `int` `y, ` `int` `z)` `{` ` ` ` ` `// Condition if we can't reach in Z steps` ` ` `if` `(z < Math.Abs(x) + Math.Abs(y) ||` ` ` `(z - Math.Abs(x) - Math.Abs(y)) % 2 == 1)` ` ` `{` ` ` `Console.Write(` `"Not Possible"` `+ ` `"\n"` `);` ` ` `}` ` ` `else` ` ` `Console.Write(` `"Possible"` `+ ` `"\n"` `);` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` ` ` `// Destination point coordinate` ` ` `int` `x = 5, y = 5;` ` ` `// Number of steps allowed` ` ` `int` `z = 11;` ` ` `// Function Call` ` ` `possibleToReach(x, y, z);` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` `// javascript program for the above approach` `// Function to check if it is possible` `// to reach (x, y) from origin in` `// exactly z steps` `function` `possibleToReach(x , y , z)` `{` ` ` ` ` `// Condition if we can't reach in Z steps` ` ` `if` `(z < Math.abs(x) + Math.abs(y) ||` ` ` `(z - Math.abs(x) - Math.abs(y)) % 2 == 1)` ` ` `{` ` ` `document.write(` `"Not Possible"` `+ ` `"\n"` `);` ` ` `}` ` ` `else` ` ` `document.write(` `"Possible"` `+ ` `"\n"` `);` `}` `// Driver Code` `// Destination povar coordinate` `var` `x = 5, y = 5;` `// Number of steps allowed` `var` `z = 11;` `// Function Call` `possibleToReach(x, y, z);` `// This code is contributed by Amit Katiyar` `</script>` |

**Output:**

Not Possible

**Time Complexity:** *O(1)* **Auxiliary Space:** *O(1)*

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**