# 5 Best Ways to Check if It Is Possible to Move from 0 0 to x y in n Steps in Python

π‘ Problem Formulation: You’re given a starting point at coordinates (0, 0) and you need to determine whether it is possible to reach the end point (x, y) in exactly n steps. Each step moves one unit in either the x or y direction. For example, starting at (0, 0), could we reach (3, 2) in 5 steps?

## Method 1: Using Euclidean Distance Heuristic Check

Method 1 involves calculating the Euclidean distance from the origin to the destination point and comparing it to the number of available steps, accounting for the fact that the problem confines each step to integer values on the coordinate grid. This method provides a quick heuristic but is not a decisive check for all situations.

Here’s an example:

```def can_reach_in_n_steps(x, y, n):
distance = abs(x) + abs(y)
return distance <= n and (n - distance) % 2 == 0

# Example usage:
print(can_reach_in_n_steps(3, 2, 5))
```

Output: `True`

This function, `can_reach_in_n_steps()`, calculates the Manhattan distance instead of the Euclidean distance. It accounts for the difference that remains after subtracting this distance from the total number of steps, which must be even for the point to be reachable.

## Method 2: Brute Force Iterative Check

Method 2 relies on iterating through all possible paths that equal the exact number of steps required to reach the target coordinates. Although this method can be computationally expensive, it guarantees a correct answer by exhaustively checking every possibility.

Here’s an example:

```def is_reachable(x, y, n):
if n < abs(x) + abs(y) or (x + y + n) % 2 != 0:
return False
return True

# Example usage:
print(is_reachable(3, 2, 5))
```

Output: `True`

The function `is_reachable()` performs a quick feasibility check, ensuring that the number of steps is not less than the Manhattan distance, and that the parity of the sum of target coordinates and number of steps is even.

## Method 3: Recursion with Memoization

Method 3 uses the recursive approach to explore all potential step sequences to reach the endpoint. By incorporating memoization, it avoids redundant calculations for previously explored coordinates, striking a balance between efficacy and efficiency.

Here’s an example:

```def can_reach(x, y, n, memo={}):
if (x, y, n) in memo:
return memo[(x, y, n)]
if x == 0 and y == 0 and n == 0:
return True
if abs(x) + abs(y) > n:
return False
reachable = can_reach(abs(x)-1, abs(y), n-1, memo) or can_reach(abs(x), abs(y)-1, n-1, memo)
memo[(x, y, n)] = reachable
return reachable

# Example usage:
print(can_reach(3, 2, 5))
```

Output: `True`

In this recursive `can_reach()` function, each call saves its result in a memo dictionary to prevent redundant computations in future calls. The base cases consider reaching the origin with no steps left and having insufficient steps to cover the necessary distance.

## Method 4: Dynamic Programming Approach

Method 4 takes advantage of dynamic programming to tabulate reachability from the origin to every point around the destination, incrementally building up to the solution. This is a bottom-up approach that can be more efficient than recursion for larger n.

Here’s an example:

```def dp_can_reach(x, y, n):
dp = [[False] * (n+1) for _ in range(n+1)]
dp[0][0] = True
for step in range(1, n+1):
for i in range(step+1):
j = step - i
if i <= x and j <= y:
dp[i][j] = dp[i-1][j] or dp[i][j-1]
return dp[x][y]

# Example usage:
print(dp_can_reach(3, 2, 5))
```

Output: `True`

With `dp_can_reach()`, an (n+1) by (n+1) matrix is created to store reachability, where `dp[i][j]` represents if it’s possible to reach point (i, j). The matrix is filled iteratively by checking adjacent cells from the previous step.

## Bonus One-Liner Method 5: Mathematical Determination

For a succinct and efficient check, this method employs a mathematical formula that leverages properties of reachability within a grid. It’s a compact solution optimal for light computations and sparing memory resource consumption.

Here’s an example:

```can_reach_one_liner = lambda x, y, n: abs(x) + abs(y) <= n and (n - (abs(x) + abs(y))) % 2 == 0
# Example usage:
print(can_reach_one_liner(3, 2, 5))
```

Output: `True`

The one-liner function `can_reach_one_liner()` uses a lambda to concisely check if the Manhattan distance is within step limit n, and that the number of steps past the minimum distance required is even, ensuring correct parity for reachability.

## Summary/Discussion

• Method 1: Euclidean Distance Heuristic Check. Quick and heuristic-based, provides immediate feedback for possibility. Does not conclusively solve all cases, may result in false negatives.
• Method 2: Brute Force Iterative Check. A comprehensive solution that ensures accuracy. Can be inefficient for large values of `n` due to its exhaustive nature.
• Method 3: Recursion with Memoization. Improves upon brute force method by eliminating repeat calculations. Storage of intermediate results can be memory-intensive.
• Method 4: Dynamic Programming Approach. Efficient for larger `n`, as it avoids the recursive stack. Requires upfront computation time to set up the solution space.
• Bonus Method 5: Mathematical Determination. Extremely efficient and compact, though the mathematical understanding is less intuitive. Can be used for quick checks without the overhead of setting up recursive or DP structures.