# Solving Leetcode Interviews in Seconds with AI: Self Crossing


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "335" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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. Return true if your path crosses itself or false if it does not.   Example 1:   Input: distance = [2,1,1,2] Output: true Explanation: The path crosses itself at the point (0, 1).  Example 2:   Input: distance = [1,2,3,4] Output: false Explanation: The path does not cross itself at any point.  Example 3:   Input: distance = [1,1,1,2,1] Output: true Explanation: The path crosses itself at the point (0, 0).    Constraints:  1 <= distance.length <= 105 1 <= distance[i] <= 105  

	# Explanation
	Here's the approach, complexity analysis, and Python code:

*   **Observation:** A path crosses itself if any of these conditions are met: (1) A move intersects a previous move, (2) A move ends inside the area enclosed by previous moves (crossing due to enclosure), or (3) a move overlaps with an earlier move.
*   **Algorithm:** Iterate through the `distance` array, keeping track of the past distances. Check for immediate crossings (4th move crossing the 1st, 5th crossing the 2nd and so on), or more complex ones caused by shrinking the boundaries until `i` is large enough for these conditions to become relevant. Return `True` immediately if a crossing is detected; otherwise, return `False`.
*   **Optimization:** The algorithm avoids explicit coordinate tracking by comparing distances, which is much more efficient.

*   **Complexity:** O(n) time complexity, O(1) space complexity.

	
	# Code
	```python
	def isSelfCrossing(distance):
    """
    Checks if a path defined by the distance array crosses itself.

    Args:
        distance: A list of integers representing the distances of each move.

    Returns:
        True if the path crosses itself, False otherwise.
    """
    n = len(distance)
    if n <= 3:
        return False

    for i in range(3, n):
        # Case 1: 4th line crosses the 1st line
        if distance[i] >= distance[i - 2] and distance[i - 1] <= distance[i - 3]:
            return True

        # Case 2: 5th line meets the 1st line and
        # 5th line or goes beyond the 1st line
        if i >= 4 and distance[i - 1] == distance[i - 3] and distance[i] + distance[i - 4] >= distance[i - 2]:
            return True

        # Case 3: 6th line crosses the 1st line
        if i >= 5 and distance[i] + distance[i - 4] >= distance[i - 2] and distance[i - 1] + distance[i - 5] >= distance[i - 3] and distance[i - 1] <= distance[i - 3] and distance[i] <= distance[i-2]:
            return True

    return False
	```