0507EasyArray

Nearest Matching Bin

Tracked in this browser only

Trains the technique from

LeetCode 1848Minimum Distance to the Target Element

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 single aisle of a stockroom holds bins side by side. labels[i] is the part number sitting in bin i, and a part number may appear in several bins. A picker is standing in front of bin start and needs the part numbered target.

Walking from bin i to bin j costs |i - j| paces. Return the smallest number of paces the picker must walk to stand in front of a bin holding target. The aisle is guaranteed to hold target in at least one bin.

Examples

Example 1

Input: labels = [7, 2, 9, 2, 7], target = 2, start = 2
Output: 1

Bins 1 and 3 both hold part 2 and the picker stands at bin 2, so either one is a single pace away.

Example 2

Input: labels = [9, 1, 1, 1, 42], target = 42, start = 0
Output: 4

Part 42 sits only in bin 4 and the picker stands at bin 0, so the walk is four paces.

Example 3

Input: labels = [2, 5, 2, 5, 2], target = 5, start = 4
Output: 1

Part 5 sits in bins 1 and 3 while the picker stands at bin 4, so bin 3 is one pace away.

Constraints

1 <= labels.length <= 1000
1 <= labels[i] <= 10^4
0 <= start < labels.length
target appears in labels at least once.

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_matching_bin(labels: list[int], target: int, start: int) -> int:

Java

public int nearestMatchingBin(int[] labels, int target, int start)

The intended approach

Time O(n) in the worst case, when the only match sits at the far end.Space O(1): two indices.

Check the picker's own bin first, then widen the search by one pace at a time, testing the bin that far to the left and the bin that far to the right before widening again. The first bin that matches is reached at the smallest possible number of paces, and the guarantee that `target` occurs somewhere means the widening always terminates.

Pythonentry point: nearest_matching_bin

def nearest_matching_bin(labels, target, start):
    # Widen a ring around the aisle position one step at a time and look at both
    # sides at that distance. The first hit is at the smallest distance, because
    # every smaller distance has already been rejected.
    # O(n) time in the worst case, O(1) space.
    n = len(labels)
    if labels[start] == target:
        return 0
    for step in range(1, n):
        left = start - step
        if left >= 0 and labels[left] == target:
            return step
        right = start + step
        if right < n and labels[right] == target:
            return step
    return -1

The obvious version

Walk the whole aisle, and for every bin holding `target` measure the distance from `start`, keeping the smallest. O(n) with no early exit.

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_matching_bin(labels, target, start):
    best = None
    for i in range(len(labels)):
        if labels[i] == target:
            d = i - start
            if d < 0:
                d = -d
            if best is None or d < best:
                best = d
    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