Minimum Distance to the Target Element - Practice Coding Problems

Minimum Distance to the Target Element - Problem

Array Easy

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: abs(x) is the absolute value of x.

Return abs(i - start).

It is guaranteed that target exists in nums.

Input & Output

Example 1 — Basic Case

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

› Output: 1

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

Example 2 — Multiple Targets

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

› Output: 0

💡 Note: Target 1 is at index 0, same as start. Distance is |0-0| = 0

Example 3 — Choose Closer Target

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

› Output: 0

💡 Note: Target 1 appears everywhere, including at start position. Minimum distance is 0

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Array with target value and start position

Process

Find all occurrences of target and calculate distances

Output

Return the minimum distance found

Key Takeaway

🎯 Key Insight: We only need one pass through the array to find all target occurrences and track the minimum distance to start position

Asked in

f Facebook 15 M Microsoft 12 🍎 Apple 8

The key insight is to iterate through the array once, checking each element against the target and calculating the distance from the start position. The optimal approach uses a single pass with early termination when distance 0 is found. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Occurrences	O(n)	O(1)	Find all indices with target value, then calculate minimum distance
Early Termination Optimization	O(n)	O(1)	Stop searching once we find distance 0 (target at start position)

Brute Force - Check All Occurrences — Algorithm Steps

Find all indices where nums[i] == target
Calculate abs(i - start) for each index
Return the minimum distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Array

Check each element for target value

Calculate Distance

For matches, compute abs(i - start)

Track Minimum

Keep the smallest distance found

Code -

solution.c — C

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

int solution(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() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int target, start;
    scanf("%d", &target);
    scanf("%d", &start);
    
    int result = solution(nums, numsSize, target, start);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to check each element

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum distance

✓ Linear Space

26.5K Views

Medium Frequency

~5 min Avg. Time

856 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 - Check All Occurrences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler