Shortest Distance to Target String in a Circular Array

Shortest Distance to Target String in a Circular Array - Problem

Array String Easy

Imagine you're standing at a train station on a circular subway line where trains go in both directions and eventually loop back. You're given an array of station names words and need to find the shortest path to reach your target station.

In this circular array, the last element connects back to the first element, creating an endless loop. From any starting position startIndex, you can move either:

Forward: to the next station words[(i + 1) % n]
Backward: to the previous station words[(i - 1 + n) % n]

Each move costs exactly 1 step. Your goal is to find the minimum number of steps needed to reach the target station from your starting position.

Return the shortest distance to reach the target string, or -1 if the target doesn't exist in the array.

Input & Output

example_1.py — Basic Case

$ Input: words = ["hello", "i", "am", "leetcode", "hello"], target = "hello", startIndex = 1

› Output: 1

💡 Note: Starting from index 1, we can reach "hello" at index 0 by moving 1 step counterclockwise, or reach "hello" at index 4 by moving 3 steps clockwise. The minimum is 1.

example_2.py — Target Not Found

$ Input: words = ["a", "b", "leetcode"], target = "leetcode", startIndex = 0

› Output: 1

💡 Note: Starting from index 0, we can reach "leetcode" at index 2 by moving 2 steps clockwise or 1 step counterclockwise. The minimum is 1.

example_3.py — Target Not Exists

$ Input: words = ["i", "eat", "leetcode"], target = "ate", startIndex = 0

› Output: -1

💡 Note: The target "ate" does not exist in the words array, so we return -1.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] and target consist of only lowercase English letters
0 ≤ startIndex < words.length

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

We have a circular array where the end connects to the beginning

Calculate Clockwise

Distance going forward: (target_index - start_index + n) % n

Calculate Counterclockwise

Distance going backward: (start_index - target_index + n) % n

Choose Minimum

The shortest path is the minimum of both distances

Key Takeaway

🎯 Key Insight: In a circular array, always calculate both clockwise and counterclockwise distances, then choose the minimum!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a single pass through the array to find all occurrences of the target string. For each occurrence, it calculates both clockwise and counterclockwise distances using modular arithmetic, then returns the minimum distance found. The key insight is that in a circular array, there are only two paths between any two points.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Linear Search	O(n)	O(1)	Search the array linearly and calculate distance for each occurrence
Single Pass Optimization	O(n)	O(1)	Find minimum distance in a single pass without extra data structures

Brute Force Linear Search — Algorithm Steps

Iterate through all elements in the array
For each element that matches the target, calculate the circular distance
Track the minimum distance found so far
Return the minimum distance or -1 if target not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Search

Begin at index 0, check if current element matches target

Calculate Distance

For each match, calculate both clockwise and counterclockwise distances

Track Minimum

Keep track of the minimum distance found so far

Continue Search

Continue through all elements to find the optimal path

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int closestTargetDistance(char words[][100], int n, char* target, int startIndex) {
    int minDistance = INT_MAX;
    int found = 0;
    
    for (int i = 0; i < n; i++) {
        if (strcmp(words[i], target) == 0) {
            found = 1;
            // Calculate clockwise distance
            int clockwise = (i - startIndex + n) % n;
            // Calculate counterclockwise distance
            int counterclockwise = (startIndex - i + n) % n;
            // Take minimum of both distances
            int distance = min(clockwise, counterclockwise);
            minDistance = min(minDistance, distance);
        }
    }
    
    return found ? minDistance : -1;
}

int main() {
    char words[5][100] = {"hello", "i", "am", "leetcode", "hello"};
    char target[] = "hello";
    int startIndex = 1;
    printf("%d\n", closestTargetDistance(words, 5, target, startIndex));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to find all occurrences

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum distance

✓ Linear Space

28.5K Views

Medium Frequency

~12 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler