Self Crossing - Practice Coding Problems

Self Crossing - Problem

Self Crossing Path Detection

Imagine you're programming a robot to walk in a specific pattern on a grid. The robot starts at the origin (0, 0) and follows a sequence of movements based on an array of distances. The robot moves in a counter-clockwise pattern: first north, then west, then south, then east, and so on.

Your task is to determine if the robot's path will ever cross itself - that is, whether any line segment of the path intersects with a previously drawn line segment.

Input: An array of integers distance where each element represents how far to move in the current direction.
Output: Return true if the path crosses itself, false otherwise.

Example: If distance = [2,1,1,2], the robot moves 2 units north, 1 unit west, 1 unit south, then 2 units east - creating a path that crosses itself.

Input & Output

example_1.py — Simple Crossing

$ Input: distance = [2,1,1,2]

› Output: true

💡 Note: The path goes: 2 north → 1 west → 1 south → 2 east. The fourth line (east) crosses the first line (north), forming a self-intersecting rectangle.

example_2.py — No Crossing

$ Input: distance = [1,2,3,4]

› Output: false

💡 Note: The path spirals outward: 1 north → 2 west → 3 south → 4 east. Since each segment is longer than previous ones, the path doesn't cross itself.

example_3.py — Complex Crossing

$ Input: distance = [1,1,2,1,1]

› Output: true

💡 Note: This creates a more complex pattern where the fifth line crosses the second line, demonstrating Pattern 2 from our optimal solution.

Visualization

Tap to expand

Understanding the Visualization

Start Drawing

Begin at origin, move counter-clockwise following distance array

Track Recent Segments

Keep track of the last 3-5 line segments drawn

Check Patterns

Look for the three specific crossing patterns that can occur

Detect Crossing

Return true immediately when any pattern is detected

Key Takeaway

🎯 Key Insight: Self-crossings in counter-clockwise paths only happen in 3 specific geometric patterns, allowing O(n) detection instead of O(n²) brute force

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking only fixed number of patterns per step

✓ Linear Growth

Space Complexity

O(1)

Only store the last few line segment lengths, no additional data structures

✓ Linear Space

Constraints

1 ≤ distance.length ≤ 10⁵
1 ≤ distance[i] ≤ 10⁵
The path always starts at origin (0,0) and moves counter-clockwise
Movement directions cycle: North → West → South → East → North...

Asked in

G Google 15 a Amazon 8 f Meta 5 ⊞ Microsoft 3

The optimal solution recognizes that in a counter-clockwise path, self-crossings can only occur in three specific geometric patterns. Instead of checking all O(n²) line intersections, we identify these patterns in O(n) time by examining only the last few segments as we build the path.

Common Approaches

Approach	Time	Space	Notes
✓ Geometric Pattern Recognition (Optimal)	O(n)	O(1)	Recognize that crossings only happen in 3 specific geometric patterns
Brute Force (Check All Line Intersections)	O(n²)	O(n)	Check every new line segment against all previous segments for intersection

Geometric Pattern Recognition (Optimal) — Algorithm Steps

Identify that crossings only happen with recent segments (last 3-5 segments)
Check three specific crossing patterns as we build the path
Pattern 1: Fourth line crosses first line (basic rectangle)
Pattern 2: Fifth line crosses second line (pentagon-like)
Pattern 3: Sixth line crosses first line (hexagon-like)

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern 1

Fourth line crosses first line (rectangle-like)

Pattern 2

Fifth line crosses second line (pentagon-like)

Pattern 3

Sixth line crosses first line (hexagon-like)

Code -

solution.c — C

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

bool isSelfCrossing(int* distance, int n) {
    if (n < 4) return false;
    
    for (int i = 3; i < n; i++) {
        // Pattern 1: Fourth line crosses first line
        if (distance[i-1] <= distance[i-3] && 
            distance[i] >= distance[i-2]) {
            return true;
        }
        
        if (i >= 4) {
            // Pattern 2: Fifth line crosses second line
            if (distance[i-3] == distance[i-1] && 
                distance[i-2] <= distance[i-4] + distance[i]) {
                return true;
            }
        }
        
        if (i >= 5) {
            // Pattern 3: Sixth line crosses first line
            if (distance[i-4] <= distance[i-2] && distance[i-2] <= distance[i-4] + distance[i] &&
                distance[i-5] <= distance[i-3] && distance[i-3] <= distance[i-5] + distance[i-1] &&
                distance[i-2] + distance[i-4] >= distance[i] &&
                distance[i-3] + distance[i-5] >= distance[i-1]) {
                return true;
            }
        }
    }
    
    return false;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int distance[100], size = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL && size < 100) {
        if (strlen(token) > 0) {
            distance[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%s\n", isSelfCrossing(distance, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking only fixed number of patterns per step

✓ Linear Growth

Space Complexity

O(1)

Only store the last few line segment lengths, no additional data structures

✓ Linear Space

Constraints

1 ≤ distance.length ≤ 10⁵
1 ≤ distance[i] ≤ 10⁵
The path always starts at origin (0,0) and moves counter-clockwise
Movement directions cycle: North → West → South → East → North...

17.2K Views

Medium Frequency

~35 min Avg. Time

485 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

Geometric Pattern Recognition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler