0105MediumArrayQueueSliding WindowHeap (Priority Queue)Ordered SetMonotonic Queue

Steady Pressure Span

Tracked in this browser only

Trains the technique from

LeetCode 1438Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit

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 pipeline crew samples the line pressure once a minute for a whole shift. readings[i] is the gauge value, in kilopascals, taken at minute i, and every gauge value is at least 1.

A run of consecutive minutes counts as steady when the highest and the lowest value recorded anywhere in that run differ by no more than spread. Note that this is judged on the extremes of the whole run, not on how much the gauge moves from one minute to the next.

Return how many minutes long the longest steady run is. A run of one minute has nothing to differ from itself, so the answer is never below 1.

Examples

Example 1

Input: readings = [7, 3, 9, 8, 6], spread = 3
Output: 3

Minutes 2 through 4 read 9, 8 and 6, whose extremes differ by exactly 3, so that run of three is steady. No run of four minutes is.

Example 2

Input: readings = [5, 5, 5, 1], spread = 0
Output: 3

A spread of 0 admits only runs where every value is identical, and the longest of those is the opening three minutes.

Example 3

Input: readings = [4, 10, 4], spread = 5
Output: 1

Both neighbouring pairs differ by 6, so no run of two minutes holds, and the answer falls back to a single minute.

Constraints

1 <= readings.length <= 10^5
1 <= readings[i] <= 10^9
0 <= spread <= 10^9

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

Java

public int steadyPressureSpan(int[] readings, int spread)

The intended approach

Time O(n)Space O(n)

Grow a window one minute at a time and keep two index queues alongside it: one whose values decrease, so its front is the window's highest reading, and one whose values increase, so its front is the lowest. Each new reading evicts every weaker candidate from the tails before joining. Whenever the two fronts differ by more than `spread`, advance the left edge, dropping a front when the index it holds falls out of the window. Every index is appended and removed once, so the sweep stays linear.

Pythonentry point: steady_pressure_span

def steady_pressure_span(readings, spread):
    from collections import deque
    highs = deque()
    lows = deque()
    left = 0
    best = 0
    for right in range(len(readings)):
        value = readings[right]
        while highs and readings[highs[-1]] <= value:
            highs.pop()
        highs.append(right)
        while lows and readings[lows[-1]] >= value:
            lows.pop()
        lows.append(right)
        while readings[highs[0]] - readings[lows[0]] > spread:
            if highs[0] == left:
                highs.popleft()
            if lows[0] == left:
                lows.popleft()
            left += 1
        if right - left + 1 > best:
            best = right - left + 1
    return best

The obvious version

Start at every minute and extend forward while the running extremes stay within `spread`, O(n^2).

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_steady_span(readings, spread):
    n = len(readings)
    best = 0
    for i in range(n):
        hi = readings[i]
        lo = readings[i]
        for j in range(i, n):
            if readings[j] > hi:
                hi = readings[j]
            if readings[j] < lo:
                lo = readings[j]
            if hi - lo > spread:
                break
            if j - i + 1 > best:
                best = j - i + 1
    return best

How this problem was checked

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