Escape The Ghosts - Practice Coding Problems

Escape The Ghosts - Problem

Array Math Medium

Escape The Ghosts - A PAC-MAN Style Challenge

Imagine you're playing a simplified version of PAC-MAN on an infinite 2D grid! You start at the origin [0, 0] and need to reach a target destination [x_target, y_target] before any ghosts catch you.

The Rules:
• You and all ghosts move simultaneously each turn
• Each turn, anyone can move 1 unit in any cardinal direction (north, east, south, west) or stay still
• If you reach the same square as a ghost at the same time (including the target), you lose
• You win only if you reach the target before any ghost reaches you

Your Mission: Determine if it's possible to escape regardless of how the ghosts move - meaning you have a guaranteed winning strategy!

Input & Output

example_1.py — Basic Escape

$ Input: ghosts = [[1, 0], [0, 3]], target = [0, 1]

› Output: true

💡 Note: Player needs 1 step to reach [0,1]. Ghost 1 needs |0-1| + |1-0| = 2 steps. Ghost 2 needs |0-0| + |1-3| = 2 steps. Since both ghosts need more steps than the player, escape is possible.

example_2.py — Ghost Intercepts

$ Input: ghosts = [[1, 0]], target = [2, 0]

› Output: false

💡 Note: Player needs 2 steps to reach [2,0]. The ghost at [1,0] needs |2-1| + |0-0| = 1 step. Since the ghost can reach the target faster, it can intercept the player there.

example_3.py — Equal Distance Edge Case

$ Input: ghosts = [[2, 0]], target = [1, 0]

› Output: false

💡 Note: Both player and ghost need exactly 1 step to reach [1,0]. Since they arrive simultaneously, the player does not escape (ties count as losses).

Visualization

Tap to expand

Understanding the Visualization

Calculate Your Distance

You start at the pizza shop (origin) and calculate straight-line city blocks to the customer

Check Competitor Distances

Each competitor calculates their city-block distance to the same customer

Compare Routes

If any competitor is closer or equally close, they'll arrive first or tie

Determine Winner

You win only if you're strictly closer than all competitors

Key Takeaway

🎯 Key Insight: In games where everyone moves at the same speed, Manhattan distance determines the winner - no complex simulation needed!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all ghosts to calculate distances

✓ Linear Growth

Space Complexity

O(1)

Only storing constant number of variables

✓ Linear Space

Constraints

1 ≤ ghosts.length ≤ 100
-10⁴ ≤ ghosts[i][0], ghosts[i][1] ≤ 10⁴
-10⁴ ≤ target[0], target[1] ≤ 10⁴
All points are distinct
Key constraint: Everyone moves at the same speed (1 unit per turn)

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses the key insight that this is a Manhattan distance comparison problem. Since all entities move at the same speed, if any ghost can reach the target in ≤ steps than the player, that ghost can intercept the player. The algorithm simply calculates Manhattan distances and compares them in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(5^(n*d))	O(5^(n*d))	Simulate all possible game states using BFS/DFS
Manhattan Distance Optimization	O(n)	O(1)	Compare Manhattan distances in one pass - optimal solution

Brute Force Simulation — Algorithm Steps

Start from initial state: player at [0,0], ghosts at given positions
For each turn, generate all possible moves for player and all ghosts
Use BFS to explore all possible game states
Check if player can reach target before any ghost catches them
Return true if any winning path exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Player at origin, ghosts at starting positions

Move Generation

Generate all possible moves for each entity

State Explosion

Number of states grows exponentially

Victory Check

Check if player reaches target in any timeline

Code -

solution.c — C

#include <stdlib.h>
#include <stdbool.h>

bool escapeGhosts(int** ghosts, int ghostsSize, int* ghostsColSize, int* target, int targetSize) {
    int playerDist = abs(target[0]) + abs(target[1]);
    
    for (int i = 0; i < ghostsSize; i++) {
        int ghostDist = abs(target[0] - ghosts[i][0]) + abs(target[1] - ghosts[i][1]);
        if (ghostDist <= playerDist) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(5^(n*d))

5 moves per entity (4 directions + stay), n entities, d maximum distance to target

✓ Linear Growth

Space Complexity

O(5^(n*d))

Need to store all possible game states in BFS queue

⚡ Linearithmic Space

Constraints

1 ≤ ghosts.length ≤ 100
-10⁴ ≤ ghosts[i][0], ghosts[i][1] ≤ 10⁴
-10⁴ ≤ target[0], target[1] ≤ 10⁴
All points are distinct
Key constraint: Everyone moves at the same speed (1 unit per turn)

28.5K Views

Medium Frequency

~12 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler