0215MediumArrayBinary SearchTernary Search

Kiln Ramp Peak

Tracked in this browser only

Trains the technique from

LeetCode 852Peak Index in a Mountain Array

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 pottery kiln writes down its chamber temperature once a minute for one firing cycle. The log is a single ramp: reading by reading the temperature climbs to one hottest minute, and from that minute onward it drops, reading by reading, until the cycle ends. No two neighbouring readings are ever equal, the climb is at least one minute long, and so is the drop, so the hottest minute is never the first or last entry.

You are given the log as readings. Return the position of the hottest reading, counting positions from 0.

Your routine must run in time logarithmic in the length of readings.

Examples

Example 1

Input: readings = [120, 480, 910, 300]
Output: 2

Position 2 holds 910. The readings before it climb, 120 then 480, and the reading after it, 300, is lower.

Example 2

Input: readings = [15, 62, 41, 33, 9]
Output: 1

Position 1 holds 62, above the 15 that precedes it, and every later reading is below the one before it.

Example 3

Input: readings = [0, 4, 7, 12, 300, 299]
Output: 4

The climb runs through positions 0 to 4 and the only drop is the final 299, so the hottest minute sits at position 4.

Constraints

3 <= readings.length <= 10^5
0 <= readings[i] <= 10^6
readings climbs strictly to one hottest entry and then drops strictly
the hottest entry is neither the first nor the last entry

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 kiln_ramp_peak(readings: list[int]) -> int:

Java

public int kilnRampPeak(int[] readings)

The intended approach

Time O(log n)Space O(1)

Hold a window that is known to contain the hottest minute. Compare the midpoint of the window with the reading just after it: while the log is still climbing there, the hottest minute lies strictly to the right, otherwise the midpoint itself is the rightmost candidate that survives. Each comparison halves the window, and the two bounds meet on the answer.

Pythonentry point: kiln_ramp_peak

def kiln_ramp_peak(readings):
    lo = 0
    hi = len(readings) - 1
    while lo < hi:
        mid = (lo + hi) // 2
        if readings[mid] < readings[mid + 1]:
            lo = mid + 1
        else:
            hi = mid
    return lo

The obvious version

Walk the whole log once and keep the position of the largest reading seen so far, O(n).

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_kiln_ramp_peak(readings):
    best = 0
    for i in range(1, len(readings)):
        if readings[i] > readings[best]:
            best = i
    return best

How this problem was checked

Reference solution executed against 12 test cases — 12 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