0195EasyLinked ListTwo Pointers

Pump Chain Midpoint

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 booster pipeline is a chain of pump stations. Each station knows only the pressure it runs at and which station comes next, so the chain can be travelled in one direction and its length is not recorded anywhere.

For this exercise the chain is handed to you as pressures, a flat list of the pressures in travel order, where index 0 is the station at the intake. Your answer is the same kind of flat list: the pressure of the midpoint station followed by the pressures of every station downstream of it, in travel order. That is the JSON stand-in for handing back a station and letting the rest of the chain trail behind it.

When the chain holds an even number of stations, two of them sit equally near the centre; pick the one further downstream.

Travel the chain a single time. Do not walk it once to total up the stations and then walk it again to reach the answer.

Examples

Example 1

Input: pressures = [42, 17, 63, 8, 55]
Output: [63, 8, 55]

Five stations put the centre at index 2, and the two stations downstream of it trail along behind.

Example 2

Input: pressures = [12, 30, 7, 91, 44, 6]
Output: [91, 44, 6]

Six stations leave indices 2 and 3 tied for the centre, and the tie goes to the one further downstream.

Example 3

Input: pressures = [100]
Output: [100]

A lone station is its own midpoint and has nothing trailing it.

Constraints

1 <= pressures.length <= 100
1 <= pressures[i] <= 100

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 midpoint_segment(pressures: list[int]) -> list[int]:

Java

public int[] midpointSegment(int[] pressures)

The intended approach

Time O(n)Space O(1) beyond the returned segment

Send two travellers downstream together, the quick one covering two stations for every one the steady one covers. When the quick traveller runs out of chain the steady one is parked on the midpoint, and for an even chain that lands on the later of the two centre stations, so the answer is the chain from there on. Tallying the stations the quick traveller covers and stepping the steady one on every second station does this in one pass, so the number of stations never has to be known in advance.

Pythonentry point: midpoint_segment

def midpoint_segment(pressures):
    # Time O(n): one downstream pass, no second walk and no length known up front.
    # Space O(1) beyond the returned segment: two integer tallies.
    steady = 0
    covered = 0
    for _ in pressures:
        covered += 1
        if covered % 2 == 0:
            steady += 1
    return pressures[steady:]

The obvious version

Two passes: count the stations first, then copy out everything from index count // 2 onward.

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_midpoint_segment(pressures):
    count = 0
    for _ in pressures:
        count += 1
    start = count // 2
    out = []
    for i, value in enumerate(pressures):
        if i >= start:
            out.append(value)
    return out

How this problem was checked

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