Minimum Time to Type Word Using Special Typewriter

Minimum Time to Type Word Using Special Typewriter - Problem

String Greedy Easy

Imagine you have a circular typewriter where all 26 lowercase English letters 'a' to 'z' are arranged in a perfect circle, like numbers on a clock face! 🕐

There's a pointer that starts at letter 'a' and can only type the character it's currently pointing to. The challenge? You need to type out an entire word, but first you must move the pointer to each required letter.

Movement Rules:

Each second, you can move the pointer one position clockwise or counterclockwise
Or you can type the current character the pointer is on
The letters wrap around: ...→ y → z → a → b → ...

Goal: Given a string word, return the minimum number of seconds needed to type out all characters in the word.

Example: To type "bza", you'd move a→b (1 sec), type 'b' (1 sec), move b→a→z (2 secs), type 'z' (1 sec), move z→a (1 sec), type 'a' (1 sec) = 7 seconds total.

Input & Output

example_1.py — Basic Movement

$ Input: word = "abc"

› Output: 5

💡 Note: Start at 'a': type 'a' (1s) → move to 'b' (1s) → type 'b' (1s) → move to 'c' (1s) → type 'c' (1s) = 5 seconds total

example_2.py — Wrapping Around

$ Input: word = "bza"

› Output: 7

💡 Note: Start at 'a': move to 'b' (1s) → type 'b' (1s) → move to 'z' (2s, shorter to go backwards) → type 'z' (1s) → move to 'a' (1s) → type 'a' (1s) = 7 seconds

example_3.py — Single Character

$ Input: word = "a"

› Output: 1

💡 Note: Already at 'a', just type it (1 second)

Constraints

1 ≤ word.length ≤ 100
word consists of lowercase English letters only
The pointer always starts at 'a'

Visualization

Tap to expand

Understanding the Visualization

Position Mapping

Map each letter to position: a=0, b=1, ..., z=25

Distance Calculation

For any two positions, calculate clockwise and counterclockwise distances

Optimal Path

Choose the shorter path and add typing time (1 second)

Accumulate Time

Sum all movement and typing times for final answer

Key Takeaway

🎯 Key Insight: In a circular arrangement, there are always exactly two paths between any two points. The optimal solution always chooses the shorter arc, making this a simple greedy algorithm with O(n) time complexity.

Asked in

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

This problem requires greedy optimization - for each character, calculate both clockwise and counterclockwise distances around the circular alphabet and choose the minimum path. The key insight is using modular arithmetic to handle the circular nature: clockwise = (target - current) % 26, counterclockwise = (current - target) % 26. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n)	O(1)	Calculate both clockwise and counterclockwise distances for each character transition

Brute Force Simulation — Algorithm Steps

Start with pointer at 'a' (position 0) and time = 0
For each character in word:
Calculate clockwise distance: (target - current) % 26
Calculate counterclockwise distance: (current - target) % 26
Take minimum of both distances
Add minimum distance + 1 (for typing) to total time
Update current position to target character

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at 'a'

Pointer begins at position 'a' (0 degrees)

Calculate distances

For target 'b': clockwise = 1, counterclockwise = 25

Choose shortest

Move clockwise 1 step (minimum distance)

Type character

Type 'b' (1 second), total time = 2

Code -

solution.c — C

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

int minTimeToType(char* word) {
    int currentPos = 0; // Start at 'a'
    int totalTime = 0;
    int len = strlen(word);
    
    for (int i = 0; i < len; i++) {
        int targetPos = word[i] - 'a';
        
        // Calculate clockwise distance
        int clockwise = (targetPos - currentPos + 26) % 26;
        // Calculate counterclockwise distance
        int counterclockwise = (currentPos - targetPos + 26) % 26;
        
        // Choose minimum distance
        int minDistance = (clockwise < counterclockwise) ? clockwise : counterclockwise;
        
        // Add movement time + typing time (1 second)
        totalTime += minDistance + 1;
        
        // Update current position
        currentPos = targetPos;
    }
    
    return totalTime;
}

int main() {
    char word[101];
    if (fgets(word, sizeof(word), stdin)) {
        // Remove newline if present
        word[strcspn(word, "\n")] = 0;
        printf("%d\n", minTimeToType(word));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each character in the word once, doing constant work for each

✓ Linear Growth

Space Complexity

O(1)

We only use a few variables to track current position and total time

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

890 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler