Self Crossing

Self Crossing - Problem

You are given an array of integers distance. You start at the point (0, 0) on an X-Y plane, and you move distance[0] meters to the north, then distance[1] meters to the west, distance[2] meters to the south, distance[3] meters to the east, and so on.

In other words, after each move, your direction changes counter-clockwise. The directions cycle as: North → West → South → East → North...

Return true if your path crosses itself, or false if it does not.

Input & Output

Example 1 — Basic Crossing

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

› Output: true

💡 Note: Starting at (0,0): North 2→(0,2), West 1→(-1,2), South 1→(-1,1), East 2→(1,1). The fourth line (East) crosses the first line (North).

Example 2 — No Crossing

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

› Output: false

💡 Note: The path forms an expanding spiral. Starting at (0,0): North 1→(0,1), West 2→(-2,1), South 3→(-2,-2), East 4→(2,-2). No lines intersect.

Example 3 — Simple Square

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

› Output: true

💡 Note: Forms a perfect 1×1 square: North→(0,1), West→(-1,1), South→(-1,0), East→(0,0). The fourth line ends exactly at the starting point.

Constraints

1 ≤ distance.length ≤ 10⁵
1 ≤ distance[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18

The key insight is recognizing that in a counter-clockwise movement pattern, a line can only cross with one of the three most recent previous lines. The optimal approach uses pattern recognition to detect specific geometric crossing conditions in O(n) time and O(1) space.

Common Approaches

✓ Brute Force - Check All Line Intersections

⏱️ Time: O(n²) Space: O(n)

Create all line segments from the path and check if any two non-adjacent segments intersect. This requires checking all possible pairs of line segments.

Optimized Pattern Recognition

⏱️ Time: O(n) Space: O(1)

Instead of checking all pairs, analyze the specific patterns where crossings can occur. Due to the counter-clockwise movement pattern, a line can only cross with one of the three most recent previous lines.

Brute Force - Check All Line Intersections — Algorithm Steps

Generate all line segments from the distance array
Check every pair of non-adjacent segments for intersection
Return true if any intersection is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Segments

Create line segments from each move

Check Pairs

Test every pair of non-adjacent segments

Find Intersection

Return true if any pair intersects

Code -

solution.c — C

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

typedef struct {
    int start[2], end[2];
} Segment;

int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }

bool intersects(Segment seg1, Segment seg2) {
    int x1 = seg1.start[0], y1 = seg1.start[1];
    int x2 = seg1.end[0], y2 = seg1.end[1];
    int x3 = seg2.start[0], y3 = seg2.start[1];
    int x4 = seg2.end[0], y4 = seg2.end[1];
    
    // Check if horizontal and vertical lines intersect
    if (x1 == x2) { // seg1 is vertical
        if (y3 == y4) { // seg2 is horizontal
            return (min(x3, x4) <= x1 && x1 <= max(x3, x4) &&
                   min(y1, y2) <= y3 && y3 <= max(y1, y2));
        }
    } else if (y1 == y2) { // seg1 is horizontal
        if (x3 == x4) { // seg2 is vertical
            return (min(y3, y4) <= y1 && y1 <= max(y3, y4) &&
                   min(x1, x2) <= x3 && x3 <= max(x1, x2));
        }
    }
    
    return false;
}

bool solution(int* distance, int size) {
    if (size < 4) {
        return false;
    }
    
    // Generate line segments
    Segment* segments = malloc(size * sizeof(Segment));
    int x = 0, y = 0;
    int directions[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}}; // N, W, S, E
    
    for (int i = 0; i < size; i++) {
        int dx = directions[i % 4][0];
        int dy = directions[i % 4][1];
        int x2 = x + dx * distance[i];
        int y2 = y + dy * distance[i];
        segments[i].start[0] = x; segments[i].start[1] = y;
        segments[i].end[0] = x2; segments[i].end[1] = y2;
        x = x2; y = y2;
    }
    
    // Check all pairs of non-adjacent segments
    for (int i = 0; i < size; i++) {
        for (int j = i + 2; j < size; j++) {
            // Allow checking first and last segment if there are enough segments
            if (intersects(segments[i], segments[j])) {
                free(segments);
                return true;
            }
        }
    }
    
    free(segments);
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse array manually
    static int distance[1000];
    int size = 0;
    
    // Skip opening bracket and parse numbers
    char* ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ' ') {
            ptr++;
            continue;
        }
        
        char* endptr;
        long val = strtol(ptr, &endptr, 10);
        if (endptr != ptr) {
            distance[size++] = (int)val;
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    
    printf(solution(distance, size) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Check all pairs of line segments, n segments gives n² comparisons

✓ Linear Growth

Space Complexity

O(n)

Store all n line segments with their coordinates

✓ Linear Space

67.5K Views

Medium Frequency

~45 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 Line Intersections — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler