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

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the peak element index in the array

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

DSA Python

def find_peak(nums):
    left, right = 0, len(nums) - 1
    while left < right:
        mid = (left + right) // 2
        if nums[mid] > nums[mid + 1]:
            right = mid
        else:
            left = mid + 1
    return left

print(find_peak([1, 3, 20, 4, 1, 0]))

A 0

B 1

C 3

D 2

💡 Hint

Think about how the binary search moves left or right based on the comparison between mid and mid+1.

The function finds the peak by comparing mid element with its next element. If mid is greater, the peak is on the left side including mid; else on the right side excluding mid. The peak index is 2 where value is 20.

❓ Predict Output

intermediate

Output of peak element index for strictly increasing array

What index does the binary search peak finder return for a strictly increasing array?

DSA Python

def find_peak(nums):
    left, right = 0, len(nums) - 1
    while left < right:
        mid = (left + right) // 2
        if nums[mid] > nums[mid + 1]:
            right = mid
        else:
            left = mid + 1
    return left

print(find_peak([1, 2, 3, 4, 5, 6]))

A 0

B 5

C 3

D 4

💡 Hint

In a strictly increasing array, the peak is at the last element.

Since the array is strictly increasing, the peak is the last element at index 5. The binary search moves right until it reaches the end.

❓ Predict Output

advanced

Find peak element index in array with multiple peaks

What is the output index of the peak element for the array with multiple peaks?

DSA Python

def find_peak(nums):
    left, right = 0, len(nums) - 1
    while left < right:
        mid = (left + right) // 2
        if nums[mid] > nums[mid + 1]:
            right = mid
        else:
            left = mid + 1
    return left

print(find_peak([1, 3, 5, 2, 4, 6, 1]))

A 5

B 3

C 1

D 6

💡 Hint

The function returns one peak index, not necessarily the first peak.

The binary search finds a peak at index 5 where value is 6. Other peaks exist but the algorithm returns one valid peak.

🧠 Conceptual

advanced

Why binary search works for finding a peak element

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

A Because the peak is always at the middle index

B Because the array is always sorted

C Because at least one side of mid always contains a peak due to the array's property

D Because the array contains only one peak

💡 Hint

Think about the comparison between mid and mid+1 and what it implies about the slope.

If nums[mid] > nums[mid+1], a peak must exist on the left side including mid; else on the right side. This property ensures binary search finds a peak.

🔧 Debug

expert

Identify the error in the peak element binary search code

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

DSA Python

def find_peak(nums):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] > nums[mid + 1]:
            right = mid - 1
        else:
            left = mid + 1
    return left

print(find_peak([1, 2, 3, 4, 5, 6]))

A IndexError because nums[mid + 1] can go out of range

B Returns wrong peak index 3

C Runs correctly and returns 2

D Infinite loop due to wrong loop condition

💡 Hint

Check the loop condition and how mid+1 is accessed near the array end.

The loop condition allows mid to be the last index, so nums[mid + 1] causes IndexError. The condition should be left < right to avoid this.

Practice

1. What is a peak element in an array when using binary search to find it?

easy

A. The first element of the array

B. An element that is greater than its neighbors

C. The smallest element in the array

D. An element equal to its neighbors

Solution

1. Step 1: Understand the definition of a peak element

   A peak element is one that is strictly greater than its neighbors on both sides (or just one side if at the boundary).

2. Step 2: Relate to binary search goal

   Binary search finds such an element by comparing middle elements with neighbors to decide search direction.

3. Final Answer:

   An element that is greater than its neighbors -> Option B

4. Quick Check:

   Peak element = greater than neighbors [OK]

Hint: Peak element is bigger than neighbors, not smallest [OK]

Common Mistakes:

• Thinking peak is smallest element
• Confusing peak with first or last element always
• Assuming peak equals neighbors

2. Which of the following is the correct Python syntax to start a binary search loop for finding a peak element in array nums?

easy

A. while left <= right:

B. for i in nums:

C. if left < right:

D. while left < right:

Solution

1. Step 1: Identify binary search loop condition

   Binary search typically uses while left < right: to narrow down the search space until left meets right.

2. Step 2: Compare options

   while left <= right: is common in classic binary search but for peak finding, while left < right: is preferred to avoid infinite loops.

3. Final Answer:

   while left < right: -> Option D

4. Quick Check:

   Binary search loop uses < not <= [OK]

Hint: Use while left < right for peak element binary search [OK]

Common Mistakes:

• Using for loop instead of while
• Using <= which may cause infinite loop
• Using if instead of loop

3. What will be the output index of the peak element for the array nums = [1, 3, 20, 4, 1, 0] using binary search peak finding?

medium

A. 2

B. 1

C. 3

D. 0

Solution

1. Step 1: Identify peak candidates

   Check elements: 20 at index 2 is greater than neighbors 3 and 4, so index 2 is a peak.

2. Step 2: Binary search logic

   Binary search will find index 2 by comparing mid elements and moving left or right accordingly.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Peak at index 2 with value 20 [OK]

Hint: Peak is local max, here 20 at index 2 [OK]

Common Mistakes:

• Choosing first or last element incorrectly
• Confusing index with value
• Not checking both neighbors

4. Given this code snippet to find a peak element, what is the error?

def find_peak(nums):
    left, right = 0, len(nums) - 1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] < nums[mid + 1]:
            left = mid + 1
        else:
            right = mid - 1
    return left

medium

A. Index mid + 1 may cause out of range error

B. Return should be right instead of left

C. Loop condition should be while left < right

D. Mid calculation is incorrect

Solution

1. Step 1: Check index usage in condition

   The code accesses nums[mid + 1] without checking if mid + 1 is within array bounds.

2. Step 2: Identify potential error

   If mid is at the last index, mid + 1 causes an out of range error.

3. Final Answer:

   Index mid + 1 may cause out of range error -> Option A

4. Quick Check:

   Accessing nums[mid + 1] risks out of range [OK]

Hint: Check array bounds before accessing mid+1 [OK]

Common Mistakes:

• Ignoring array boundary checks
• Using <= in loop causing infinite loop
• Returning wrong index

5. You have an array nums = [10, 20, 15, 2, 23, 90, 67]. Using binary search, which index will be returned as a peak element? Consider multiple peaks exist.

hard

A. 1

B. 4

C. 5

D. 6

Solution

1. Step 1: Identify all peak elements

   Peaks are at index 1 (20 > 10 and 15), index 5 (90 > 23 and 67).

2. Step 2: Understand binary search behavior

   Binary search may return any peak, but typically it finds the one in the middle or right side depending on comparisons.

3. Step 3: Trace binary search on given array

   Mid starts near center; since nums[mid] < nums[mid+1] at some point, search moves right, finally returning index 5.

4. Final Answer:

   5 -> Option C

5. Quick Check:

   Binary search finds peak at index 5 with value 90 [OK]

Hint: Binary search may return any peak; here index 5 is found [OK]

Common Mistakes:

• Assuming only first peak is returned
• Ignoring binary search direction logic
• Confusing index with value