You are given an array x of n positive numbers. You start at point (0,0) and moves x[0] metres to the north, then x[1] metres to the west,
    x[2] metres to the south,
    x[3] metres to the east and so on. In other words, after each move your direction changes
    counter-clockwise.


    Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.



Example 1:

Given x = [2, 1, 1, 2],
?????
?   ?
???????>
    ?

Return true (self crossing)




Example 2:

Given x = [1, 2, 3, 4],
????????
?      ?
?
?
?????????????>

Return false (not self crossing)




Example 3:

Given x = [1, 1, 1, 1],
?????
?   ?
?????>

Return true (self crossing)



Credits:Special thanks to @dietpepsi for adding this problem and creating all test cases.

Difficulty: interview

Starter code:

class Solution:
    def isSelfCrossing(self, x: List[int]) -> bool:
        

Solutions:
class Solution:
     def isSelfCrossing(self, x):
         """
         :type x: List[int]
         :rtype: bool
         """
         if not x or len(x) < 4:
             return False
         i = 3
         while i < len(x):
             #print(i)
             if x[i] >= x[i-2] and x[i-1] <= x[i-3]:
                 print('case 1')
                 return True
             elif i >= 4 and x[i-1] == x[i-3] and x[i] + x[i-4] >= x[i-2]:
                 print('case 2')
                 return True
             elif i >= 5 and x[i-4] < x[i-2] <= x[i] + x[i-4] and x[i-1] <= x[i-3] <= x[i] + x[i-5]:
                 print('case 3')
                 return True
             i += 1
         return False

class Solution:
     def isSelfCrossing(self, x):
         """
         :type x: List[int]
         :rtype: bool
         """
         b = c = d = e = 0
         for a in x:
             if d >= b > 0 and (a >= c or a >= c-e >= 0 and f >= d-b):
                 return True
             b, c, d, e, f = a, b, c, d, e
         return False


class Solution:
     def isSelfCrossing(self, x):
         """
         :type x: List[int]
         :rtype: bool
         """
         n = len(x)
         if n < 4:
             return False
 
         i = 3
         while i < n:
             if x[i] >= x[i - 2] and x[i - 3] >= x[i - 1]:
                 return True
             if i >= 4:
                 if x[i - 1] == x[i - 3] and x[i] + x[i - 4] >= x[i - 2]:
                     return True
             if i >= 5:
                 if x[i] >= x[i - 2] - x[i - 4] >= 0 and x[i - 5] >= x[i - 3] - x[i - 1] >= 0:
                     return True
             i += 1
         return False


class Solution:
     def isSelfCrossing(self, x):
         """
         :type x: List[int]
         :rtype: bool
         """
         l = (len(x))
         iscross = False
         if l < 4: return False
         for i in range(3, l):
             #情况1
             if x[i-3]>=x[i-1] and x[i-2]<=x[i]:
                 return True
             #情况2
             if i>=4 and x[i-4]+x[i]>=x[i-2] and x[i-3]==x[i-1]:
                 return True
             #情况3 
             if i>=5 and x[i-5]+x[i-1]>=x[i-3] and x[i-4]+x[i]>=x[i-2] and x[i-2]>=x[i-4] and x[i-2]>x[i-4] and x[i-3]>x[i-5] and x[i-1]<x[i-3]:
                 return True
             iscross = False
         return iscross