Count Hills and Valleys in an Array - Practice Coding Problems

Count Hills and Valleys in an Array - Problem

Array Easy

You are given a 0-indexed integer array nums. Your task is to count the number of hills and valleys in this array.

What is a Hill?
An index i is part of a hill if the closest non-equal neighbors on both sides are smaller than nums[i].

What is a Valley?
An index i is part of a valley if the closest non-equal neighbors on both sides are larger than nums[i].

Important Rules:

Adjacent equal elements belong to the same hill or valley
An element must have non-equal neighbors on both sides to be part of a hill or valley
Each hill or valley is counted as one unit, regardless of how many consecutive equal elements it contains

For example, in [2,4,1,1,6,5]:

Index 1 (value 4) forms a hill (neighbors 2 and 1 are both smaller)
Indices 2,3 (values 1,1) form one valley (neighbors 4 and 6 are both larger)
Index 4 (value 6) forms a hill (neighbors 1 and 5)

Return the total count of hills and valleys.

Input & Output

example_1.py — Basic Hills and Valleys

$ Input: nums = [2,4,1,1,6,5]

› Output: 3

💡 Note: At index 1: 4 > 2 and 4 > 1 (hill). At indices 2-3: 1 < 4 and 1 < 6 (valley, counted once). At index 4: 6 > 1 and 6 > 5 (hill). Total: 3

example_2.py — All Equal Elements

$ Input: nums = [6,6,5,5,4,1]

› Output: 0

💡 Note: After compression: [6,5,4,1]. This is strictly decreasing, so no element has neighbors on both sides that are smaller or larger. No hills or valleys exist.

example_3.py — Single Peak

$ Input: nums = [1,4,3]

› Output: 1

💡 Note: At index 1: 4 > 1 and 4 > 3, forming one hill. Total: 1

Constraints

3 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
Important: Adjacent equal elements belong to the same hill or valley

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

Look at the elevation array [2,4,1,1,6,5]

Compress Plateaus

Treat consecutive equal elevations as single formations: [2,4,1,6,5]

Identify Peaks

Find elevations higher than both neighbors: 4 and 6 are hills

Identify Valleys

Find elevations lower than both neighbors: 1 is a valley

Key Takeaway

🎯 Key Insight: By treating consecutive equal elements as single formations and looking for local extrema, we can efficiently count hills and valleys in one pass through a compressed representation.

Asked in

a Amazon 15 f Meta 12 G Google 8 ⊞ Microsoft 6

The optimal approach uses array compression to remove consecutive duplicates, then identifies local maxima (hills) and local minima (valleys) in a single pass with O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Find Neighbors for Each Element)	O(n²)	O(1)	For each element, find closest non-equal neighbors and check if it forms a hill or valley
One-Pass Optimal Solution	O(n)	O(n)	Track direction changes while scanning the array once, treating equal elements as part of same formation

Brute Force (Find Neighbors for Each Element) — Algorithm Steps

Iterate through each index from 1 to n-2 (can't be first or last)
For each index, find the closest non-equal neighbor to the left
Find the closest non-equal neighbor to the right
If both neighbors exist and current element is higher than both, it's a hill
If both neighbors exist and current element is lower than both, it's a valley
Skip consecutive equal elements to avoid double counting

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 1

Begin checking from the second element

Search left neighbor

Find closest non-equal element to the left

Search right neighbor

Find closest non-equal element to the right

Compare values

Determine if current element forms hill or valley

Code -

solution.c — C

#include <stdio.h>

int countHillsAndValleys(int* nums, int numsSize) {
    if (numsSize < 3) return 0;
    
    int count = 0;
    int i = 1;
    
    while (i < numsSize - 1) {
        // Find left neighbor
        int left = i - 1;
        while (left >= 0 && nums[left] == nums[i]) {
            left--;
        }
        
        // Find right neighbor
        int right = i + 1;
        while (right < numsSize && nums[right] == nums[i]) {
            right++;
        }
        
        // Check if we have both neighbors
        if (left >= 0 && right < numsSize) {
            // Check if it's a hill or valley
            if ((nums[i] > nums[left] && nums[i] > nums[right]) ||
                (nums[i] < nums[left] && nums[i] < nums[right])) {
                count++;
            }
        }
        
        // Skip equal elements
        while (i < numsSize - 1 && nums[i] == nums[i + 1]) {
            i++;
        }
        i++;
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, for each element we might scan the entire array to find non-equal neighbors

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track neighbors and count

✓ Linear Space

26.7K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Find Neighbors for Each Element) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler