Shift Distance Between Two Strings - Practice Coding Problems

Shift Distance Between Two Strings - Problem

Imagine you have a magical typewriter where each letter can transform into its neighbors in the alphabet, but each transformation has a different cost! 🎭

You're given two strings s and t of the same length, along with two cost arrays:

nextCost[j] - cost to shift letter at alphabet index j to the next letter (e.g., 'a'→'b', 'z'→'a')
previousCost[j] - cost to shift letter at alphabet index j to the previous letter (e.g., 'b'→'a', 'a'→'z')

Your mission is to find the minimum total cost to transform string s into string t using these shift operations. The alphabet wraps around, so 'z' can become 'a' and vice versa!

Example: If s = "abc" and t = "bcd", you could shift each character forward once, with total cost being nextCost[0] + nextCost[1] + nextCost[2].

Input & Output

example_1.py — Basic Transformation

$ Input: s = "abc", t = "bcd", nextCost = [1,1,1,...], previousCost = [2,2,2,...]

› Output: 3

💡 Note: Transform each character forward once: 'a'→'b' (cost 1), 'b'→'c' (cost 1), 'c'→'d' (cost 1). Total cost = 3.

example_2.py — Circular Wrap Around

$ Input: s = "az", t = "ba", nextCost = [1,1,...,10], previousCost = [10,10,...,1]

› Output: 2

💡 Note: For 'a'→'b': forward costs 1. For 'z'→'a': forward costs 10, backward costs 1, so choose backward. Total = 1 + 1 = 2.

example_3.py — Same Characters

$ Input: s = "hello", t = "hello", nextCost = [1,2,3,...], previousCost = [1,2,3,...]

› Output: 0

💡 Note: No transformation needed since source and target strings are identical. Total cost = 0.

Constraints

1 ≤ s.length == t.length ≤ 10⁵
s and t consist only of lowercase English letters
nextCost.length == previousCost.length == 26
1 ≤ nextCost[i], previousCost[i] ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Set up the carousel

Place source and target characters on the circular alphabet

Calculate clockwise cost

Sum up nextCost values going forward around the circle

Calculate counterclockwise cost

Sum up previousCost values going backward around the circle

Choose optimal path

Select the direction with minimum total transformation cost

Key Takeaway

🎯 Key Insight: In a circular alphabet, there are only 2 paths between any characters - we just calculate both costs and pick the minimum!

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal approach calculates the minimum cost path for each character transformation by comparing both clockwise and counterclockwise directions around the circular alphabet. Since there are only 2 possible paths between any two letters, we can efficiently determine the cheaper route in O(26) per character.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Path Calculation	O(n * 26)	O(1)	Calculate minimum cost for each character by comparing both circular directions
Brute Force (Try All Paths)	O(n * 26^26)	O(26)	For each character, explore all possible transformation paths recursively

Optimal Path Calculation — Algorithm Steps

For each character pair (source, target), calculate alphabet distance
Calculate forward path cost by summing nextCost values
Calculate backward path cost by summing previousCost values
Choose the minimum cost between both directions
Sum all minimum costs for final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify source and target

Mark the starting and ending characters on the alphabet circle

Calculate forward cost

Sum up nextCost values going clockwise to target

Calculate backward cost

Sum up previousCost values going counterclockwise to target

Choose minimum

Select the path with lower total cost

Code -

solution.c — C

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

long long getMinCost(char fromChar, char toChar, int* nextCost, int* previousCost) {
    if (fromChar == toChar) return 0;
    
    int fromIdx = fromChar - 'a';
    int toIdx = toChar - 'a';
    
    // Calculate forward path cost
    long long forwardCost = 0;
    int current = fromIdx;
    while (current != toIdx) {
        forwardCost += nextCost[current];
        current = (current + 1) % 26;
    }
    
    // Calculate backward path cost
    long long backwardCost = 0;
    current = fromIdx;
    while (current != toIdx) {
        current = (current - 1 + 26) % 26;
        backwardCost += previousCost[current];
    }
    
    return (forwardCost < backwardCost) ? forwardCost : backwardCost;
}

long long shiftDistance(char* s, char* t, int* nextCost, int* previousCost) {
    long long totalCost = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        totalCost += getMinCost(s[i], t[i], nextCost, previousCost);
    }
    
    return totalCost;
}

int main() {
    char s[1001], t[1001];
    int nextCost[26], previousCost[26];
    
    scanf("%s", s);
    scanf("%s", t);
    
    for (int i = 0; i < 26; i++) {
        scanf("%d", &nextCost[i]);
    }
    
    for (int i = 0; i < 26; i++) {
        scanf("%d", &previousCost[i]);
    }
    
    printf("%lld\n", shiftDistance(s, t, nextCost, previousCost));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * 26)

For each of n characters, we traverse at most 26 positions around the alphabet

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

28.5K Views

Medium Frequency

~18 min Avg. Time

847 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

Optimal Path Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler