This is a trivial problem where we need to check each element as per its constraints. So an element is peak if it's not the corner element and it's strictly greater than its neighbours. So the algorithm would be-

Let n=number of elements and peak be number of peaks

1. Peak =0 initially

2. for i 0 to n-1
       if(i==0 or i==n-1)
           Skip this as it's corner elements and can't be peak
       Else if(arr[i]>arr[i-1] and arr[i]>arr[i+1])
           Increment peak
       End if
   End for
   

3. Peak is the final result

What can be done as part of optimizing further?

One think we can do is instead of checking each and every element to be a peak, we can skip few elements. If an element(arr[i]) is peak then we can skip the immediate right neighbour(arr[i+1]) as that can’t be peak as per constraints. This can be done in terms of optimization, but still will lead to O(n) complexity.

Since the algo is pretty intuitive and self-explanatory I am not going for dry run. However you can do a dry run for better understanding.

C++ Implementation:

#include <bits/stdc++.h>
using namespace std;

#define endl "\n"

int arr[100];

int main()
{
    int test_case;
    cin >> test_case;
 
    for (int tc = 1; tc <= test_case; tc++) {
        int n;
 
        cin >> n;
 
        int count = 0;
 
        for (int i = 0; i < n; i++) {
            cin >> arr[i];
        }
        for (int i = 0; i < n; i++) {
            if (i != 0 && i != n - 1 && arr[i] > arr[i - 1] && arr[i] > arr[i + 1])
                count++;
        }

        cout << "Case #" << tc << ": " << count << endl;
    }
 
    return 0;
}

Output:

4
3
10 20 14
Case #1: 1
4
7 7 7 7
Case #2: 0
3
10 3 10
Case #3: 0
5
10 90 20 90 10
Case #4: 2