I’m trying to figure out if my proof is valid, I think it makes intuitive sense but am worried I’m missing something. Any help would be much appreciated!

# Question

`A peak element is an element that is greater than its neighbors. Given an input array nums, where nums[i] ≠ nums[i+1], find a peak element and return its index. The array may contain multiple peaks, in that case return the index to any one of the peaks is fine. You may imagine that nums[-1] = nums[n] = -∞. Example 1: Input: nums = [1,2,3,1] Output: 2 Explanation: 3 is a peak element and your function should return the index number 2. Example 2: Input: nums = [1,2,1,3,5,6,4] Output: 1 or 5 Explanation: Your function can return either index number 1 where the peak element is 2, or index number 5 where the peak element is 6. `

# Solution

`public int findPeakElement(int[] nums) { for (int i = 0; i < nums.length-1; i++) { if (nums[i] > nums[i + 1]) { return i; } } return nums.length - 1; } `

## Why don’t you have to check the left neighbor at each element?

Assume towards a contradiction that we are iterating through `nums`

, yet to discover a peak, and we come across and element at index `i`

whose right-neighbor at index `i+1`

is strictly smaller. If the element at index `i`

were **not** a peak then the element at index `i-1`

would have to be strictly larger. Then we have that

`nums[i-1] > nums[i] > nums[i+1] `

This then implies that `nums[i+1]`

is the last element in a strictly decreasing sequence of elements (that we’ve seen), the start of which must be a peak (either the sequence starts at index `0`

or it starts at index `k, 0 < k < i`

). This contradicts our assumption, therefore the first element whose right-neighbor is strictly smaller is a local peak.