Path Crossing - Practice Coding Problems

Path Crossing - Problem

Imagine you're a robot starting at the origin (0, 0) on a 2D coordinate plane. You receive a sequence of movement commands as a string, where each character represents a direction:

'N' - Move one unit North (y + 1)
'S' - Move one unit South (y - 1)
'E' - Move one unit East (x + 1)
'W' - Move one unit West (x - 1)

Your task is to determine if the robot's path crosses itself at any point. In other words, return true if the robot visits any coordinate it has previously been to, and false otherwise.

Example: If the path is "NESWW", the robot moves North to (0,1), East to (1,1), South to (1,0), West to (0,0), and West again to (-1,0). Since it revisits (0,0), the answer is true.

Input & Output

example_1.py — Basic Path Crossing

$ Input: path = "NES"

› Output: false

💡 Note: The robot moves North to (0,1), East to (1,1), then South to (1,0). All positions are unique, so no crossing occurs.

example_2.py — Path Returns to Origin

$ Input: path = "NESWW"

› Output: true

💡 Note: The robot moves North to (0,1), East to (1,1), South to (1,0), West to (0,0) - returning to the starting position, then West to (-1,0). Since it revisits (0,0), the path crosses itself.

example_3.py — Single Character Path

$ Input: path = "N"

› Output: false

💡 Note: The robot only moves once from (0,0) to (0,1). With only two unique positions, no crossing is possible.

Constraints

1 ≤ path.length ≤ 10⁴
path[i] is either 'N', 'S', 'E', or 'W'
The robot starts at the origin (0, 0)

Visualization

Tap to expand

Understanding the Visualization

Initialize

Robot starts at origin (0,0) and marks this position

Move

Robot moves based on command and calculates new position

Check

Look up if this position was visited before using hash set

Decision

If position exists, return true; otherwise, add to set and continue

Key Takeaway

🎯 Key Insight: Hash sets provide constant-time lookups, transforming an O(n²) brute force problem into an optimal O(n) solution by eliminating the need to check all previous positions.

Asked in

G Google 35 a Amazon 28 🍎 Apple 22 ⊞ Microsoft 18

The optimal solution uses a hash set to track visited positions in O(1) time. We start at origin (0,0), then for each move, we calculate the new position and check if it already exists in our set. If found, we return true (path crosses). Otherwise, we add the position to the set and continue. This achieves O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Previous Positions)	O(n²)	O(n)	Store all positions in a list and check against all previous positions for each move
One-Pass Hash Set (Optimal)	O(n)	O(n)	Use a hash set to track visited positions and detect duplicates in O(1) time

Brute Force (Check All Previous Positions) — Algorithm Steps

Start at origin (0, 0) and add it to our positions list
For each move in the path, calculate the new position
Check if this new position exists in our list of previous positions
If found, return true (path crosses itself)
If not found, add the position to our list
If we complete all moves without finding a duplicate, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Origin

Begin at (0,0) and store in positions list

Move and Check

For each move, calculate new position and check against all previous positions

Linear Search

Iterate through all stored positions to find duplicates

Add Position

If no duplicate found, add current position to list

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Position;

bool isPathCrossing(char* path) {
    int len = strlen(path);
    Position* positions = (Position*)malloc((len + 1) * sizeof(Position));
    positions[0] = (Position){0, 0}; // Start at origin
    int posCount = 1;
    int x = 0, y = 0;
    
    for (int i = 0; i < len; i++) {
        // Update position based on move
        switch (path[i]) {
            case 'N': y++; break;
            case 'S': y--; break;
            case 'E': x++; break;
            case 'W': x--; break;
        }
        
        Position currentPos = {x, y};
        
        // Check if we've been here before
        for (int j = 0; j < posCount; j++) {
            if (positions[j].x == currentPos.x && positions[j].y == currentPos.y) {
                free(positions);
                return true;
            }
        }
        
        positions[posCount++] = currentPos;
    }
    
    free(positions);
    return false;
}

int main() {
    char path[1001];
    fgets(path, sizeof(path), stdin);
    
    // Remove newline and quotes
    int len = strlen(path);
    if (path[len-1] == '\n') path[len-1] = '\0';
    if (path[0] == '"') {
        memmove(path, path + 1, strlen(path));
        path[strlen(path) - 1] = '\0';
    }
    
    printf("%s\n", isPathCrossing(path) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n moves, we potentially check against all previous positions, leading to 1+2+3+...+n comparisons

⚠ Quadratic Growth

Space Complexity

O(n)

We store all visited positions in a list, which can be at most n+1 positions

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Previous Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler