0831EasyArrayString

Nearest Stop on the Loop Line

Tracked in this browser only

Trains the technique from

LeetCode 2515Shortest Distance to Target String in a Circular 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 tram runs a loop line. stops lists the name painted on each stop in the order the tram passes them, and the stop after the last one in the list is the first one again.

A driver standing at the stop in slot startIndex wants to reach a stop named target. One step moves to the neighbouring stop in either direction, and stepping past either end of the list carries on round the loop.

Return the fewest steps that reach a stop named target, or -1 if no stop carries that name. A step count is never negative, so -1 can only mean the name is absent.

Examples

Example 1

Input: stops = ["quay", "mill", "park", "dock", "mill"], target = "mill", startIndex = 3
Output: 1

A stop named "mill" sits in slot 4, which is one step forward from slot 3. Another sits in slot 1, which is two steps back.

Example 2

Input: stops = ["zz", "yy", "xx", "ww", "vv"], target = "xx", startIndex = 4
Output: 2

From slot 4 the tram reaches slot 2 in two steps backwards, passing slot 3 on the way. Going forward instead would wrap round the loop and take three steps.

Example 3

Input: stops = ["quay", "mill", "park"], target = "yard", startIndex = 1
Output: -1

No stop on the loop is named "yard", so the answer is -1.

Constraints

1 <= stops.length <= 100
1 <= stops[i].length <= 100
stops[i] and target consist of lowercase English letters only
0 <= startIndex <= 99
startIndex < stops.length

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 nearest_stop(stops: list[str], target: str, startIndex: int) -> int:

Java

public int nearestStop(String[] stops, String target, int startIndex)

The intended approach

Time O(n) for n stops: one pass with constant work per stop.Space O(1): only the running best is kept.

Walk the list once. For each stop carrying the wanted name, the two ways round the loop cost the forward gap and the backward gap, each taken modulo the number of stops, so the cheaper of the two is that stop's cost. Keep the smallest cost seen, and report -1 if the name never appears.

Pythonentry point: nearest_stop

def nearest_stop(stops, target, startIndex):
    n = len(stops)
    best = -1
    for i, name in enumerate(stops):
        if name != target:
            continue
        ahead = (i - startIndex) % n
        back = (startIndex - i) % n
        step = ahead if ahead < back else back
        if best < 0 or step < best:
            best = step
    return best

The obvious version

Grow a step budget from zero and, at each budget, look at the stop that many steps ahead and that many steps behind, returning the first budget that lands on the wanted name. Reads the same stops repeatedly rather than costing each one once.

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_nearest_stop(stops, target, startIndex):
    n = len(stops)
    for step in range(n):
        if stops[(startIndex + step) % n] == target:
            return step
        if stops[(startIndex - step) % n] == target:
            return step
    return -1

How this problem was checked

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