Shortest Distance to Target String in a Circular Array

Shortest Distance to Target String in a Circular Array - Problem

Array String Easy

You are given a 0-indexed circular string array words and a string target. A circular array means that the array's end connects to the array's beginning.

Formally, the next element of words[i] is words[(i + 1) % n] and the previous element of words[i] is words[(i - 1 + n) % n], where n is the length of words.

Starting from startIndex, you can move to either the next word or the previous word with 1 step at a time.

Return the shortest distance needed to reach the string target. If the string target does not exist in words, return -1.

Input & Output

Example 1 — Basic Case

$ Input: words = ["happy","sad","corner","leetcode","pass","around"], target = "leetcode", startIndex = 1

› Output: 2

💡 Note: From index 1 ("sad"), we can reach "leetcode" at index 3 by moving 2 steps clockwise (1→2→3) or 4 steps counterclockwise (1→0→5→4→3). The minimum is 2.

Example 2 — Target at Start

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

› Output: 0

💡 Note: The target "a" is already at the starting position (index 0), so the distance is 0.

Example 3 — Target Not Found

$ Input: words = ["i","eat","code"], target = "day", startIndex = 1

› Output: -1

💡 Note: The target "day" does not exist in the 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

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that in a circular array, we can reach any element by moving in two directions - clockwise or counterclockwise. The optimal approach is to find all occurrences of the target and calculate the minimum circular distance. Best approach is the optimized single-pass solution. Time: O(n), Space: O(k) where k is the number of target occurrences.

Common Approaches

✓ Linear Search Both Directions

⏱️ Time: O(n) Space: O(1)

Start from the given index and search in both directions (clockwise and counterclockwise) until we find the target string. Calculate the distance for both directions and return the minimum.

Single Pass with Distance Calculation

⏱️ Time: O(n) Space: O(k)

Traverse the array once to find all positions of the target string, then calculate the minimum circular distance from the start index to any occurrence.

Linear Search Both Directions — Algorithm Steps

Search clockwise from startIndex until target is found or we complete the circle
Search counterclockwise from startIndex until target is found or we complete the circle
Return the minimum of both distances, or -1 if target not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at startIndex

Search Both Ways

Check clockwise and counterclockwise

Return Minimum

Return the shorter distance found

Code -

solution.c — C

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

#define MIN(a, b) ((a) < (b) ? (a) : (b))

int solution(char** words, int wordsSize, char* target, int startIndex) {
    int minDistance = -1;
    
    // Search clockwise
    for (int i = 0; i < wordsSize; i++) {
        int currentIndex = (startIndex + i) % wordsSize;
        if (strcmp(words[currentIndex], target) == 0) {
            if (minDistance == -1) {
                minDistance = i;
            } else {
                minDistance = MIN(minDistance, i);
            }
            break;
        }
    }
    
    // Search counterclockwise
    for (int i = 0; i < wordsSize; i++) {
        int currentIndex = (startIndex - i + wordsSize) % wordsSize;
        if (strcmp(words[currentIndex], target) == 0) {
            if (minDistance == -1) {
                minDistance = i;
            } else {
                minDistance = MIN(minDistance, i);
            }
            break;
        }
    }
    
    return minDistance;
}

int main() {
    char line[10000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    // Count words
    int wordsSize = 0;
    int inQuote = 0;
    for (int i = 0; line[i] != '\0'; i++) {
        if (line[i] == '"') {
            if (!inQuote) {
                wordsSize++;
            }
            inQuote = !inQuote;
        }
    }
    
    // Allocate words array
    char** words = (char**)malloc(wordsSize * sizeof(char*));
    for (int i = 0; i < wordsSize; i++) {
        words[i] = (char*)malloc(101 * sizeof(char));
    }
    
    // Parse words
    int wordIdx = 0;
    char* ptr = line;
    inQuote = 0;
    int charIdx = 0;
    
    while (*ptr) {
        if (*ptr == '"') {
            if (inQuote) {
                words[wordIdx][charIdx] = '\0';
                wordIdx++;
                charIdx = 0;
            }
            inQuote = !inQuote;
        } else if (inQuote) {
            words[wordIdx][charIdx++] = *ptr;
        }
        ptr++;
    }
    
    // Read target
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    char target[101];
    int idx = 0;
    for (int i = 0; line[i] != '\0' && line[i] != '\n'; i++) {
        if (line[i] != '"') {
            target[idx++] = line[i];
        }
    }
    target[idx] = '\0';
    
    // Read startIndex
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    int startIndex = atoi(line);
    
    int result = solution(words, wordsSize, target, startIndex);
    
    printf("%d\n", result);
    
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, we search the entire array in both directions

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track indices and distances

✓ Linear Space

25.0K Views

Medium Frequency

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

Linear Search Both Directions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler