Shortest Word Distance III - Practice Coding Problems

Shortest Word Distance III - Problem

Array String Easy

You're given an array of strings wordsDict and two target words word1 and word2 that exist in the array. Your task is to find the shortest distance between any occurrence of these two words in the list.

The distance between two words is defined as the absolute difference between their indices in the array.

Special case: Unlike the basic version of this problem, word1 and word2 may be the same word! When they are identical, you need to find the shortest distance between any two different occurrences of that word.

Example: In ["practice", "makes", "perfect", "coding", "makes"], the distance between "makes" at indices 1 and 4 is |4 - 1| = 3.

Input & Output

basic_example.py — Different Words

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "coding", word2 = "practice"

› Output: 3

💡 Note: The word 'coding' appears at index 3, and 'practice' appears at index 0. The distance between them is |3 - 0| = 3.

same_words.py — Same Words

$ Input: wordsDict = ["practice", "makes", "perfect", "coding", "makes"], word1 = "makes", word2 = "makes"

› Output: 3

💡 Note: The word 'makes' appears at indices 1 and 4. Since word1 and word2 are the same, we find the shortest distance between different occurrences: |4 - 1| = 3.

edge_case.py — Adjacent Words

$ Input: wordsDict = ["a", "b", "a"], word1 = "a", word2 = "b"

› Output: 1

💡 Note: The word 'a' appears at indices 0 and 2, 'b' appears at index 1. The shortest distances are |0-1|=1 and |2-1|=1. Both give minimum distance of 1.

Constraints

1 ≤ wordsDict.length ≤ 3 × 10⁴
1 ≤ wordsDict[i].length ≤ 10
wordsDict[i] consists of lowercase English letters
word1 and word2 are in wordsDict
word1 and word2 may be the same

Visualization

Tap to expand

Understanding the Visualization

Start the search

Begin walking through the concert seating chart from left to right

Spot first friend

When you find your first friend, remember their location

Find second friend

Continue walking and measure distance when you find the second friend

Update closest pair

Keep track of the shortest distance found between any pair of friends

Key Takeaway

🎯 Key Insight: By tracking only the most recent positions of each target word during a single pass, we can find the minimum distance efficiently without needing to check all possible pairs.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a one-pass tracking approach with O(n) time complexity. By tracking the most recent positions of both target words as we iterate through the array, we can calculate the minimum distance efficiently. The key insight is that we only need to track the most recent positions since older positions will never yield a shorter distance than recent ones.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Tracking (Optimal)	O(n)	O(1)	Track the most recent positions of both words in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every pair of positions where the target words appear

One-Pass Tracking (Optimal) — Algorithm Steps

Initialize variables to track most recent positions of word1 and word2
Iterate through the array once
When we find word1, update its position and calculate distance to word2 if seen
When we find word2, update its position and calculate distance to word1 if seen
Handle special case: if word1 == word2, track previous position separately
Keep track of minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize tracking

Set up variables to track most recent positions of both target words

Iterate and track

Move through array, updating positions when target words are found

Calculate on-the-fly

When finding a target word, immediately calculate distance to the other

Update minimum

Keep track of the shortest distance found so far

Code -

solution.c — C

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

int shortestWordDistance(char** wordsDict, int dictSize, char* word1, char* word2) {
    int pos1 = -1, pos2 = -1;
    int minDistance = INT_MAX;
    
    for (int i = 0; i < dictSize; i++) {
        if (strcmp(word1, word2) == 0) {
            if (strcmp(wordsDict[i], word1) == 0) {
                if (pos1 != -1) {
                    int distance = i - pos1;
                    if (distance < minDistance) {
                        minDistance = distance;
                    }
                }
                pos1 = i;
            }
        } else {
            if (strcmp(wordsDict[i], word1) == 0) {
                pos1 = i;
                if (pos2 != -1) {
                    int distance = abs(pos1 - pos2);
                    if (distance < minDistance) {
                        minDistance = distance;
                    }
                }
            } else if (strcmp(wordsDict[i], word2) == 0) {
                pos2 = i;
                if (pos1 != -1) {
                    int distance = abs(pos1 - pos2);
                    if (distance < minDistance) {
                        minDistance = distance;
                    }
                }
            }
        }
    }
    
    return minDistance;
}

int main() {
    char* words[] = {"practice", "makes", "perfect", "coding", "makes"};
    printf("%d\n", shortestWordDistance(words, 5, "makes", "coding"));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant time operations at each step

✓ Linear Growth

Space Complexity

O(1)

Only storing a few integer variables for positions

✓ Linear Space

28.4K Views

Medium Frequency

~15 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

One-Pass Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler