{x}
blog image

Minimum Distance to the Target Element

Given an integer array nums (0-indexed) and two integers target and start, find an index i such that nums[i] == target and abs(i - start) is minimized. Note that abs(x) is the absolute value of x.

Return abs(i - start).

It is guaranteed that target exists in nums.

 

Example 1:

Input: nums = [1,2,3,4,5], target = 5, start = 3
Output: 1
Explanation: nums[4] = 5 is the only value equal to target, so the answer is abs(4 - 3) = 1.

Example 2:

Input: nums = [1], target = 1, start = 0
Output: 0
Explanation: nums[0] = 1 is the only value equal to target, so the answer is abs(0 - 0) = 0.

Example 3:

Input: nums = [1,1,1,1,1,1,1,1,1,1], target = 1, start = 0
Output: 0
Explanation: Every value of nums is 1, but nums[0] minimizes abs(i - start), which is abs(0 - 0) = 0.

 

Constraints:

  • 1 <= nums.length <= 1000
  • 1 <= nums[i] <= 104
  • 0 <= start < nums.length
  • target is in nums.

1848. Minimum Distance to the Target Element

Problem Description

Given an integer array nums, a target integer, and a start index, find the index i where nums[i] == target and abs(i - start) is minimized. Return abs(i - start). It's guaranteed that target exists in nums.

Solution Approach

The most straightforward approach is a single pass through the array. We iterate through nums, checking if each element is equal to the target. If it is, we calculate the absolute difference between the current index i and the start index, and update the minimum distance found so far.

Time and Space Complexity Analysis

  • Time Complexity: O(n), where n is the length of the input array nums. We iterate through the array once in the worst case.
  • Space Complexity: O(1). We use only a constant amount of extra space to store variables like the minimum distance.

Code Implementation

Here's the code implementation in several programming languages:

Python

class Solution:
    def getMinDistance(self, nums: List[int], target: int, start: int) -> int:
        min_distance = float('inf')  # Initialize with positive infinity
        for i, num in enumerate(nums):
            if num == target:
                min_distance = min(min_distance, abs(i - start))
        return min_distance

Java

class Solution {
    public int getMinDistance(int[] nums, int target, int start) {
        int minDistance = Integer.MAX_VALUE; // Initialize with maximum integer value
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                minDistance = Math.min(minDistance, Math.abs(i - start));
            }
        }
        return minDistance;
    }
}

C++

class Solution {
public:
    int getMinDistance(vector<int>& nums, int target, int start) {
        int minDistance = INT_MAX; // Initialize with maximum integer value
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == target) {
                minDistance = min(minDistance, abs(i - start));
            }
        }
        return minDistance;
    }
};

Javascript

/**
 * @param {number[]} nums
 * @param {number} target
 * @param {number} start
 * @return {number}
 */
var getMinDistance = function(nums, target, start) {
    let minDistance = Infinity; // Initialize with positive infinity
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] === target) {
            minDistance = Math.min(minDistance, Math.abs(i - start));
        }
    }
    return minDistance;
};

Go

func getMinDistance(nums []int, target int, start int) int {
	minDistance := math.MaxInt32 // Initialize with maximum integer value
	for i, num := range nums {
		if num == target {
			minDistance = min(minDistance, abs(i-start))
		}
	}
	return minDistance
}
 
func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}
 
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

These solutions all follow the same basic algorithm, differing only in syntax and specific library functions used for absolute value and minimum calculations. They all achieve the same O(n) time and O(1) space complexity.