0692EasyArray

Is the Survey Line a Single Ridge

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A survey walks a straight line and records the ground elevation at each station, giving heights in walking order.

The line is a single ridge when both of the following hold:

it has at least three stations;
there is a station p, neither the first nor the last, such that the elevations strictly increase from the first station up to p, and strictly decrease from p on to the last station.

Strictly means no two neighbouring stations on either side may record the same elevation. Return true when the line is a single ridge and false otherwise.

Examples

Example 1

Input: heights = [0, 3, 1]
Output: true

Station 1 is neither the first nor the last, the elevation rises from 0 to 3 before it, and falls from 3 to 1 after it.

Example 2

Input: heights = [4, 7, 9, 11]
Output: false

The elevations keep rising to the last station, so there is no station strictly inside the line with a fall after it.

Example 3

Input: heights = [1, 2, 2, 1]
Output: false

Stations 1 and 2 both record 2. That pair is neither a strict rise nor a strict fall, so no station splits the line into the two required parts.

Constraints

1 <= heights.length <= 10^4
0 <= heights[i] <= 10^4

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def is_single_ridge(heights: list[int]) -> bool:

Java

public boolean isSingleRidge(int[] heights)

The intended approach

Time O(n) for n stations: each station is passed at most once by each walk.Space O(1).

Walk forward from the first station while each elevation is strictly above the one before, which stops at the top of the climb. That stop has to be strictly inside the line, so a line that never rises or that rises to its very last station is rejected at once. From there, walk forward again while each elevation is strictly below the one before, and the line qualifies only if this second walk reaches the last station.

Pythonentry point: is_single_ridge

def is_single_ridge(heights):
    n = len(heights)
    if n < 3:
        return False
    i = 0
    while i + 1 < n and heights[i] < heights[i + 1]:
        i += 1
    if i == 0 or i == n - 1:
        return False          # no rise at all, or the rise never stops
    while i + 1 < n and heights[i] > heights[i + 1]:
        i += 1
    return i == n - 1         # the fall has to reach the far end

The obvious version

Find the position of the highest elevation, reject it when it sits at either end, and then confirm with two sweeps that every neighbouring pair before it rises and every neighbouring pair from it onwards falls.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_is_single_ridge(heights):
    n = len(heights)
    if n < 3:
        return False
    top = heights.index(max(heights))
    if top == 0 or top == n - 1:
        return False
    rising = all(heights[k] < heights[k + 1] for k in range(top))
    falling = all(heights[k] > heights[k + 1] for k in range(top, n - 1))
    return rising and falling

How this problem was checked

Reference solution executed against 16 test cases — 16 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in