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

Challenge - 5 Problems

❓ Predict Output

intermediate

Find Peak Element Output

What is the output of the following C# code that finds a peak element index in the array using binary search?

DSA C#

int[] nums = {1, 3, 20, 4, 1, 0};
int FindPeakElement(int[] arr) {
    int left = 0, right = arr.Length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] > arr[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}
Console.WriteLine(FindPeakElement(nums));

A 1

B 3

C 0

D 2

💡 Hint

Think about how the binary search narrows down the peak by comparing mid and mid+1 elements.

The binary search compares elements at mid and mid+1. Since 20 > 4, it moves right to mid, eventually finding index 2 as the peak.

🧠 Conceptual

intermediate

Understanding Peak Element Conditions

Which condition correctly describes a peak element in an array for the binary search approach?

A An element that is greater than its immediate neighbors or at array boundaries.

B An element that is smaller than both neighbors.

C An element that is equal to its neighbors.

D An element that is the smallest in the entire array.

💡 Hint

A peak is like a mountain top, higher than what is next to it.

A peak element is greater than its neighbors or is at the boundary where only one neighbor exists.

❓ Predict Output

advanced

Binary Search Peak Element Edge Case

What is the output of the code when the input array is strictly increasing?

DSA C#

int[] nums = {1, 2, 3, 4, 5};
int FindPeakElement(int[] arr) {
    int left = 0, right = arr.Length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] > arr[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}
Console.WriteLine(FindPeakElement(nums));

A 2

B 4

C 0

D 3

💡 Hint

In a strictly increasing array, the peak is at the end.

Since each element is smaller than the next, the binary search moves right until the last index, which is the peak.

🔧 Debug

advanced

Identify the Error in Peak Element Code

What error will the following code produce when run?

DSA C#

int[] nums = {1, 2, 3, 4, 5};
int FindPeakElement(int[] arr) {
    int left = 0, right = arr.Length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] > arr[mid + 1]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return left;
}
Console.WriteLine(FindPeakElement(nums));

A IndexOutOfRangeException

B Returns 4 correctly

C Infinite loop

D Compilation error

💡 Hint

Check the condition when mid+1 is accessed near the array end.

The code can access arr[mid + 1] when mid is at the last index, causing IndexOutOfRangeException.

🚀 Application

expert

Find Peak Element in a Large Array

Given a large array where multiple peak elements exist, which index will the binary search method return?

DSA C#

int[] nums = {1, 3, 2, 5, 4, 6, 1};
int FindPeakElement(int[] arr) {
    int left = 0, right = arr.Length - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] > arr[mid + 1]) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}
Console.WriteLine(FindPeakElement(nums));

A 3

B 5

C 1

D 6

💡 Hint

The binary search finds one peak, not necessarily the highest.

The method returns index 1, a peak found by the binary search process.

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 smaller than its neighbors

C. An element that is greater than its neighbors

D. The last element of the array

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: Apply this to binary search context

   Binary search finds such an element by comparing mid element with neighbors to decide the search direction.

3. Final Answer:

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

4. Quick Check:

   Peak element = greater than neighbors [OK]

Hint: Peak element > neighbors, use binary search to find it fast [OK]

Common Mistakes:

• Confusing peak with minimum element
• Thinking peak must be at array ends
• Assuming peak equals maximum element in array

2. Which of the following is the correct C# syntax to calculate the middle index in binary search to avoid overflow?

easy

A. int mid = (low + high) / 2;

B. int mid = (high - low) / 2 + high;

C. int mid = (low - high) / 2;

D. int mid = low + (high - low) / 2;

Solution

1. Step 1: Understand overflow risk in mid calculation

   Using (low + high) / 2 can overflow if low and high are large integers.

2. Step 2: Use safe calculation to avoid overflow

   Calculate mid as low + (high - low) / 2 to prevent overflow.

3. Final Answer:

   int mid = low + (high - low) / 2; -> Option D

4. Quick Check:

   Safe mid calculation = low + (high - low) / 2 [OK]

Hint: Use low + (high - low) / 2 to avoid overflow [OK]

Common Mistakes:

• Using (low + high) / 2 causing overflow
• Subtracting incorrectly in mid calculation
• Mixing up low and high in formula

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

medium

A. 3

B. 2

C. 1

D. 0

Solution

1. Step 1: Identify peak candidates in the array

   Array: [1, 3, 20, 4, 1, 0]. 20 at index 2 is greater than neighbors 3 and 4.

2. Step 2: Binary search finds peak at index 2

   Binary search compares mid elements and narrows down to index 2 as peak.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Peak element index = 2 [OK]

Hint: Peak is local max; check neighbors to confirm [OK]

Common Mistakes:

• Choosing first or last element incorrectly
• Confusing peak with global max
• Not checking both neighbors

4. Identify the error in this C# binary search code snippet for finding a peak element:

int mid = low + (high - low) / 2;
if (arr[mid] < arr[mid + 1])
    low = mid + 1;
else
    high = mid - 1;

medium

A. It may cause index out of range when mid is at the last element

B. The mid calculation can overflow

C. The condition should be arr[mid] > arr[mid + 1]

D. The else block should set low = mid + 1

Solution

1. Step 1: Check boundary conditions for arr[mid + 1]

   If mid is the last index, arr[mid + 1] causes index out of range error.

2. Step 2: Need to ensure mid + 1 is within array bounds

   Code must check or limit mid to avoid accessing beyond array length.

3. Final Answer:

   It may cause index out of range when mid is at the last element -> Option A

4. Quick Check:

   Check array bounds before accessing mid+1 [OK]

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

Common Mistakes:

• Ignoring array boundary causing runtime errors
• Incorrect mid calculation causing overflow
• Wrong comparison direction in if condition

5. Given a mountain array [0, 2, 4, 7, 5, 3, 1], which modification to the binary search algorithm helps find the peak element efficiently?

hard

A. Compare mid with mid+1 and move low or high accordingly

B. Always move low to mid+1 regardless of comparison

C. Use linear search instead of binary search

D. Compare mid with mid-1 and move high to mid-1 always

Solution

1. Step 1: Understand mountain array property

   Mountain array increases then decreases, so peak is where arr[mid] > arr[mid+1].

2. Step 2: Use binary search comparing mid and mid+1

   If arr[mid] < arr[mid+1], move low to mid+1; else move high to mid to find peak.

3. Final Answer:

   Compare mid with mid+1 and move low or high accordingly -> Option A

4. Quick Check:

   Compare mid and mid+1 to find peak [OK]

Hint: Compare mid and mid+1 to decide search direction [OK]

Common Mistakes:

• Moving pointers incorrectly ignoring array shape
• Using linear search losing binary search efficiency
• Comparing mid with mid-1 incorrectly