Shortest Distance to a Character - Practice Coding Problems

Shortest Distance to a Character - Problem

Imagine you're a robot moving along a string, and you need to find the shortest distance to your favorite character from every position!

Given a string s and a character c that appears at least once in s, return an array where each element represents the minimum distance from that position to the nearest occurrence of character c.

The distance between two positions i and j is simply |i - j| (absolute difference of their indices).

Example: For string "loveleetcode" and character 'e', the distances would be [3,2,1,0,1,0,0,1,2,3,4] because each position finds its nearest 'e' and calculates the distance.

Input & Output

example_1.py — Basic case

$ Input: s = "loveleetcode", c = 'e'

› Output: [3,2,1,0,1,0,0,1,2,3,4]

💡 Note: The character 'e' appears at indices 3, 5, 6, and 7. Each position calculates its distance to the nearest 'e'.

example_2.py — Single character

$ Input: s = "aaab", c = 'b'

› Output: [3,2,1,0]

💡 Note: Only one 'b' at index 3, so distances are calculated from all positions to index 3.

example_3.py — Target at start

$ Input: s = "abcde", c = 'a'

› Output: [0,1,2,3,4]

💡 Note: Target character 'a' is at the beginning, so distances increase linearly from left to right.

Constraints

1 ≤ s.length ≤ 10⁴
s[i] and c are lowercase English letters
It is guaranteed that c occurs in s

Visualization

Tap to expand

Understanding the Visualization

Mark Street Lights

Identify positions where target character 'e' appears (street lights)

Forward Pass

Walk left to right, tracking distance from the last street light seen

Backward Pass

Walk right to left, updating distances if we find closer street lights behind

Final Distances

Each house now knows its distance to the nearest street light in either direction

Key Takeaway

🎯 Key Insight: Two passes capture all possibilities - every position is closest to a target either from the left or from the right, never both directions equally (except when distance is 0).

Asked in

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

The optimal solution uses a two-pass approach: forward pass tracks distances from target characters on the left, backward pass considers targets on the right, and we take the minimum distance at each position. Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Optimal Solution	O(n)	O(1)	Forward pass for left distances, backward pass for right distances, take minimum
Brute Force (Nested Loops)	O(n²)	O(1)	For each position, scan entire string to find closest target character

Two-Pass Optimal Solution — Algorithm Steps

Initialize answer array and distance tracker
Forward pass: track distance from last seen target character
When target found, reset distance to 0
Backward pass: track distance from target characters on right
Update answer with minimum of current value and right distance

Visualization

Tap to expand

Step-by-Step Walkthrough

Forward Pass

Track distance from last seen target character going left to right

Backward Pass

Track distance from target characters going right to left

Take Minimum

Each position keeps the minimum distance from either direction

Code -

solution.c — C

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

int* shortestToChar(char* s, char c, int* returnSize) {
    int n = strlen(s);
    *returnSize = n;
    int* answer = (int*)malloc(n * sizeof(int));
    
    // Initialize with max values
    for (int i = 0; i < n; i++) {
        answer[i] = INT_MAX;
    }
    
    // Forward pass - distance from left
    int dist = INT_MAX;
    for (int i = 0; i < n; i++) {
        if (s[i] == c) {
            dist = 0;
        } else if (dist != INT_MAX) {
            dist++;
        }
        answer[i] = dist;
    }
    
    // Backward pass - distance from right
    dist = INT_MAX;
    for (int i = n - 1; i >= 0; i--) {
        if (s[i] == c) {
            dist = 0;
        } else if (dist != INT_MAX) {
            dist++;
        }
        if (dist < answer[i]) {
            answer[i] = dist;
        }
    }
    
    return answer;
}

int main() {
    char s[1000];
    char c;
    scanf("%s %c", s, &c);
    
    int returnSize;
    int* result = shortestToChar(s, c, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the string, each taking O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for distance tracking (excluding output array)

✓ Linear Space

85.2K Views

Medium Frequency

~15 min Avg. Time

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

Two-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler