# A subarray A[i], A[i+1], ..., A[j] of A is said to be turbulent if and only if:
#
# For i <= k < j, A[k] > A[k+1] when k is odd, and A[k] < A[k+1] when k is even;
# OR, for i <= k < j, A[k] > A[k+1] when k is even, and A[k] < A[k+1] when k is odd.
# That is, the subarray is turbulent if the comparison sign flips between each adjacent pair of elements in the
# subarray.
#
# Return the length of a maximum size turbulent subarray of A.
#
#
#
# Example 1:
#
# Input: [9,4,2,10,7,8,8,1,9]
# Output: 5
# Explanation: (A[1] > A[2] < A[3] > A[4] < A[5])
# Example 2:
#
# Input: [4,8,12,16]
# Output: 2
# Example 3:
#
# Input: [100]
# Output: 1
#
#
# Note:
#
# 1 <= A.length <= 40000
# 0 <= A[i] <= 10^9

class Solution(object):
    def maxTurbulenceSize(self, A):
        """
        :type A: List[int]
        :rtype: int
        """
        if len(A) <= 2:
            return len(A)

        l, r, res, tmpL = 0, 1, 2, 2
        while r + 1 < len(A):
            if (A[r] - A[l]) * (A[r + 1] - A[r]) < 0:
                tmpL += 1
                res = max(res, tmpL)
            else:
                tmpL = 2

            l, r = l + 1, r + 1
        return res


if __name__ == '__main__':
    print Solution().maxTurbulenceSize([9, 4, 2, 10, 7, 8, 8, 1, 9])
    print Solution().maxTurbulenceSize([4, 8, 12, 16])
    print Solution().maxTurbulenceSize([100])
    print Solution().maxTurbulenceSize([1, 6, 2, 7, 3, 8, 4, 9, 5, 10])
    print Solution().maxTurbulenceSize([5, 3, 6, 7, 8, 3, 4, 2, 5])
    print Solution().maxTurbulenceSize([5, 4, 3, 2, 1])
