Shortest Word Distance - Practice Coding Problems

Shortest Word Distance - Problem

Array String Easy

Imagine you're reading through a document and need to find how close two specific words appear to each other. Given an array of strings wordsDict representing words in a document and two different strings word1 and word2 that exist in the array, your task is to find the shortest distance between these two words.

The distance is defined as the absolute difference between the indices where the words appear. For example, if word1 appears at index 1 and word2 appears at index 4, the distance is |4 - 1| = 3.

Goal: Return the minimum possible distance between any occurrence of word1 and word2 in the given array.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: "coding" appears at index 3 and "practice" appears at index 0, so the distance is |3 - 0| = 3.

example_2.py — Multiple Occurrences

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

› Output: 1

💡 Note: "makes" appears at indices 1 and 4, "coding" appears at index 3. The shortest distance is between indices 4 and 3: |4 - 3| = 1.

example_3.py — Adjacent Words

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

› Output: 1

💡 Note: "a" is at index 0 and "b" is at index 1, so the distance is |1 - 0| = 1. This is the minimum possible distance for different words.

Visualization

Tap to expand

Understanding the Visualization

Start walking

Begin traversing the array, looking for target words

Mark positions

When we find word1 or word2, remember their positions

Calculate distance

If both words have been seen, calculate current distance

Update minimum

Keep the smallest distance found so far

Key Takeaway

🎯 Key Insight: We only need to track the most recent positions of both target words. Older positions will never yield a shorter distance than the current closest pair, allowing us to solve this efficiently in a single pass.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking each element once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for position tracking variables

✓ Linear Space

Constraints

2 ≤ wordsDict.length ≤ 3 × 10⁴
1 ≤ wordsDict[i].length ≤ 10
wordsDict[i] consists of lowercase English letters
word1 and word2 are in wordsDict
word1 ≠ word2

Asked in

G Google 12 a Amazon 8 in LinkedIn 6 ⊞ Microsoft 4

The optimal solution uses a one-pass approach with position tracking. As we iterate through the array, we keep track of the most recent positions of both target words and update the minimum distance whenever both words have been encountered. This achieves O(n) time and O(1) space complexity, making it the most efficient approach for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Find all occurrences of both words and check every possible pair
One-Pass Tracking (Optimal)	O(n)	O(1)	Track the most recent positions of both words in a single pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through the array to find all indices of word1
Iterate through the array again to find all indices of word2
Compare every index of word1 with every index of word2
Keep track of the minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find first word

Locate all occurrences of word1

Find second word

For each word1, check all occurrences of word2

Calculate distances

Compute distance between each pair

Track minimum

Keep the smallest distance found

Code -

solution.c — C

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

int shortestDistance(char** wordsDict, int size, char* word1, char* word2) {
    int minDistance = INT_MAX;
    
    for (int i = 0; i < size; i++) {
        if (strcmp(wordsDict[i], word1) == 0) {
            for (int j = 0; j < size; j++) {
                if (strcmp(wordsDict[j], word2) == 0) {
                    int dist = abs(i - j);
                    if (dist < minDistance) {
                        minDistance = dist;
                    }
                }
            }
        }
    }
    
    return minDistance;
}

int main() {
    char** wordsDict = malloc(1000 * sizeof(char*));
    char word1[100], word2[100];
    int size = 0;
    
    // Simple parsing
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, ",\"[] \n");
    while (token != NULL && size < 1000) {
        wordsDict[size] = malloc(strlen(token) + 1);
        strcpy(wordsDict[size], token);
        size++;
        token = strtok(NULL, ",\"[] \n");
    }
    
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    
    // Remove newlines and quotes
    word1[strcspn(word1, "\n\"")] = 0;
    word2[strcspn(word2, "\n\"")] = 0;
    
    printf("%d\n", shortestDistance(wordsDict, size, word1, word2));
    
    for (int i = 0; i < size; i++) {
        free(wordsDict[i]);
    }
    free(wordsDict);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, if most elements are word1 or word2, we might compare O(n) × O(n) pairs

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

2 ≤ wordsDict.length ≤ 3 × 10⁴
1 ≤ wordsDict[i].length ≤ 10
wordsDict[i] consists of lowercase English letters
word1 and word2 are in wordsDict
word1 ≠ word2

42.2K Views

Medium Frequency

~12 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler