Minimum Distance to the Target Element - Practice Coding Problems

Minimum Distance to the Target Element - Problem

Array Easy

Imagine you're standing at a specific position on a number line and need to find the closest occurrence of your target number. Given an integer array nums and two integers target and start, your goal is to find the minimum distance from the starting position to any occurrence of the target element.

More formally, you need to:

Find an index i where nums[i] == target
Calculate the absolute distance abs(i - start)
Return the minimum possible distance among all valid indices

Example: If nums = [1,2,3,4,5], target = 3, and start = 1, the target 3 is at index 2, so the distance is abs(2-1) = 1.

Note: It's guaranteed that the target exists in the array.

Input & Output

example_1.py — Basic Example

$ Input: nums = [1,2,3,4,5], target = 3, start = 1

› Output: 1

💡 Note: The target 3 is at index 2. Distance from start position 1 is |2-1| = 1.

example_2.py — Multiple Occurrences

$ Input: nums = [1,1,1,1,1,1,1,1,1,1], target = 1, start = 0

› Output: 0

💡 Note: Target 1 exists at every index including start position 0, so minimum distance is |0-0| = 0.

example_3.py — Edge Position

$ Input: nums = [1,2,3,4,5], target = 1, start = 4

› Output: 4

💡 Note: Target 1 is at index 0. Distance from start position 4 is |0-4| = 4.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁴
0 ≤ start < nums.length
target is guaranteed to exist in nums

Visualization

Tap to expand

Understanding the Visualization

Start Position

You're standing at position 'start' on the street (array)

Scan Street

Walk through the street checking each building (array element)

Find Coffee Shops

When you find a coffee shop (target element), measure distance from start

Track Closest

Keep track of the shortest distance found so far

Final Answer

Return the minimum distance to any coffee shop

Key Takeaway

🎯 Key Insight: We only need one pass through the array since we're looking for the minimum distance - no complex data structures needed, just track the smallest distance as we scan!

Asked in

a Amazon 35 G Google 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses a single-pass linear search with O(n) time complexity. We iterate through the array once, calculate the distance for each occurrence of the target, and track the minimum distance. This is the most efficient solution since we must check all elements to guarantee we find the absolute minimum distance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search with Distance Tracking)	O(n)	O(1)	Iterate through array, check each element, and track minimum distance

Brute Force (Linear Search with Distance Tracking) — Algorithm Steps

Initialize minimum distance to a large value (or infinity)
Iterate through each index in the array
For each element that equals the target, calculate abs(current_index - start)
Update minimum distance if current distance is smaller
Return the minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set minimum distance to infinity and start scanning from index 0

Scan Array

Check each element - if it matches target, calculate distance from start position

Update Minimum

Keep track of the smallest distance found so far

Continue

Continue scanning to ensure we find the absolute minimum distance

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int getMinDistance(int* nums, int numsSize, int target, int start) {
    int minDistance = INT_MAX;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == target) {
            int distance = abs(i - start);
            if (distance < minDistance) {
                minDistance = distance;
            }
        }
    }
    
    return minDistance;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    int numsSize = 5;
    int target = 3, start = 1;
    printf("%d\n", getMinDistance(nums, numsSize, target, start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We need to scan through the entire array once to ensure we find the minimum distance

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for tracking minimum distance

✓ Linear Space

23.5K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search with Distance Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler