Check if it is possible to reach (x, y) from origin in exactly Z steps using only plus movements

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 = 11
Output: Not Possible

Input: x = 10, y = 15, z = 25
Output: Possible

Approach:



  1. The shortest path from origin to (x, y), is |x|+|y|.
  2. So, it is clear that if Z less than |x|+|y|, then we can’t reach (x, y) from origin in exactly Z steps.
  3. 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.
  4. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

Not Possible

Time Complexity: O(1)
Auxiliary Space: 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.