<p>You may recall that an array <code>arr</code> is a <strong>mountain array</strong> if and only if:</p>

<ul>
	<li><code>arr.length &gt;= 3</code></li>
	<li>There exists some index <code>i</code> (<strong>0-indexed</strong>) with <code>0 &lt; i &lt; arr.length - 1</code> such that:
	<ul>
		<li><code>arr[0] &lt; arr[1] &lt; ... &lt; arr[i - 1] &lt; arr[i]</code></li>
		<li><code>arr[i] &gt; arr[i + 1] &gt; ... &gt; arr[arr.length - 1]</code></li>
	</ul>
	</li>
</ul>

<p>Given an integer array <code>arr</code>, return <em>the length of the longest subarray, which is a mountain</em>. Return <code>0</code> if there is no mountain subarray.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> arr = [2,1,4,7,3,2,5]
<strong>Output:</strong> 5
<strong>Explanation:</strong> The largest mountain is [1,4,7,3,2] which has length 5.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> arr = [2,2,2]
<strong>Output:</strong> 0
<strong>Explanation:</strong> There is no mountain.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
	<li><code>0 &lt;= arr[i] &lt;= 10<sup>4</sup></code></li>
</ul>

<p>&nbsp;</p>
<p><strong>Follow up:</strong></p>

<ul>
	<li>Can you solve it using only one pass?</li>
	<li>Can you solve it in <code>O(1)</code> space?</li>
</ul>

class Solution:
    def longestMountain(self, arr: List[int]) -> int:
        '''
        Problem Statement & Constraints.
        determine the longest subarray which is a mountain
        return 0 if there is no mountain subarray

        Intuition & Methdology.
        Brute force:
        For each index, take it as the top of the array
        see how far left we can go and how for right we can go
        compute the length og the mountain and keep track of the longest one
        But this would be quadratic time complexity

        Not this isn't quadratic, because for a mountain, we've identified, we can continue from the right most pointer


        Time & Space Complexity.


        '''
        largest_mountain = 0
        peak_index = 0

        while peak_index < len(arr):
            left_index = peak_index

            while left_index > 0 and arr[left_index - 1] < arr[left_index]:
                left_index -= 1

            right_index = peak_index
            while right_index < len(arr) - 1 and arr[right_index + 1] < arr[right_index]:
                right_index += 1
            
            if right_index == peak_index or left_index == peak_index:
                peak_index += 1
                continue

            largest_mountain = max(largest_mountain, right_index - left_index + 1)
            peak_index = right_index + 1

        return largest_mountain
17300