Find Peak Element Using Binary Search in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find Peak Element Output

What is the output index of the peak element for the given array using the binary search approach?

DSA Go

package main

import "fmt"

func findPeakElement(nums []int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := (left + right) / 2
        if nums[mid] > nums[mid+1] {
            right = mid
        } else {
            left = mid + 1
        }
    }
    return left
}

func main() {
    nums := []int{1, 3, 20, 4, 1, 0}
    peakIndex := findPeakElement(nums)
    fmt.Println(peakIndex)
}

A 2

B 1

C 3

D 5

💡 Hint

Check where the array value is greater than its next neighbor to decide which side to search.

The binary search compares mid element with mid+1 element. Since nums[2] = 20 is greater than nums[3] = 4, the peak lies at or before index 2. The loop narrows down to index 2 as the peak.

❓ Predict Output

intermediate

Find Peak Element Output with Multiple Peaks

What is the output index of the peak element for the array with multiple peaks using the binary search method?

DSA Go

package main

import "fmt"

func findPeakElement(nums []int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := (left + right) / 2
        if nums[mid] > nums[mid+1] {
            right = mid
        } else {
            left = mid + 1
        }
    }
    return left
}

func main() {
    nums := []int{1, 2, 1, 3, 5, 6, 4}
    peakIndex := findPeakElement(nums)
    fmt.Println(peakIndex)
}

A 5

B 1

C 4

D 3

💡 Hint

The function returns any peak, not necessarily the first peak.

The binary search finds index 5 where value 6 is a peak (greater than neighbors 5 and 4).

🧠 Conceptual

advanced

Why Binary Search Works for Finding a Peak Element

Why does the binary search approach guarantee finding a peak element in an unsorted array?

A Because the binary search checks all elements one by one to find the peak.

B Because the array is sorted, so the middle element is always a peak.

C Because if nums[mid] > nums[mid+1], a peak must exist on the left side including mid.

D Because the peak is always at the start or end of the array.

💡 Hint

Think about how comparing mid and mid+1 helps decide which side to search.

If nums[mid] > nums[mid+1], then a peak exists on the left side including mid because the slope is descending after mid. Otherwise, the peak is on the right side.

🔧 Debug

advanced

Identify the Bug in Peak Element Binary Search

What error does the following code produce when run, and why?

DSA Go

package main

import "fmt"

func findPeakElement(nums []int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := (left + right) / 2
        if nums[mid] > nums[mid+1] {
            right = mid - 1
        } else {
            left = mid + 1
        }
    }
    return left
}

func main() {
    nums := []int{1, 2, 3, 1}
    peakIndex := findPeakElement(nums)
    fmt.Println(peakIndex)
}

A Compiles but prints -1

B Infinite loop

C Returns incorrect peak index

D Index out of range runtime error

💡 Hint

Check the condition nums[mid+1] when mid is at the last index.

The loop condition allows mid to be the last index, so nums[mid+1] causes index out of range error.

🚀 Application

expert

Find Peak Element in Circular Array

Given a circular array where the end connects to the start, which approach correctly finds a peak element index?

A Use linear scan to check each element against neighbors ignoring circularity.

B Modify binary search to compare nums[mid] with nums[(mid+1) % n] and nums[(mid-1+n) % n] to handle circular neighbors.

C Apply standard binary search without changes since circularity doesn't affect peak definition.

D Sort the array first then find the maximum element index.

💡 Hint

Think about how to access neighbors in a circular array safely.

In a circular array, neighbors wrap around. Using modulo ensures correct neighbor indices for comparison in binary search.