Minimum Time to Type Word Using Special Typewriter

Minimum Time to Type Word Using Special Typewriter - Problem

String Greedy Easy

There is a special typewriter with lowercase English letters 'a' to 'z' arranged in a circle with a pointer. A character can only be typed if the pointer is pointing to that character. The pointer is initially pointing to the character 'a'.

Each second, you may perform one of the following operations:

Move the pointer one character counterclockwise or clockwise.
Type the character the pointer is currently on.

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

Input & Output

Example 1 — Basic Case

$ Input: word = "abc"

› Output: 5

💡 Note: Start at 'a': 0 seconds to move + 1 to type = 1 second. Move to 'b': 1 second + 1 to type = 2 seconds. Move to 'c': 1 second + 1 to type = 2 seconds. Total: 1 + 2 + 2 = 5 seconds.

Example 2 — Wraparound Case

$ Input: word = "bza"

› Output: 7

💡 Note: Start at 'a', move to 'b': 1 + 1 = 2 seconds. Move to 'z': counterclockwise 1 step + 1 to type = 2 seconds. Move to 'a': clockwise 1 step + 1 to type = 2 seconds. Total: 2 + 2 + 2 = 6 seconds... Wait, let me recalculate: 'a' to 'b' = 1+1=2, 'b' to 'z' = min(24,2)=2, so 2+1=3, 'z' to 'a' = min(1,25)=1, so 1+1=2. Total = 2+3+2=7.

Example 3 — Single Character

$ Input: word = "a"

› Output: 1

💡 Note: Already at 'a', so 0 seconds to move + 1 second to type = 1 second total.

Constraints

1 ≤ word.length ≤ 100
word consists of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that on a circular typewriter, there are always two paths between characters - clockwise and counterclockwise. The optimal approach uses a greedy strategy to choose the shorter path for each character. Time: O(n), Space: O(1).

Common Approaches

✓ Always Clockwise Movement

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

For each character, always move clockwise from current position to target. This ignores the fact that sometimes going counterclockwise is faster.

Greedy Optimal Path Selection

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

Calculate both clockwise and counterclockwise distances to the target character, then greedily choose the minimum. This ensures optimal movement for each character.

Always Clockwise Movement — Algorithm Steps

Start at position 'a' (0)
For each character, calculate clockwise distance
Add movement time plus 1 second to type

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Pointer starts at 'a' (position 0)

Clockwise Only

Always move clockwise to reach target

Suboptimal

May take longer path around circle

Code -

solution.c — C

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

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

int solution(char* word) {
    int current = 0;  // Start at 'a'
    int time = 0;
    int len = strlen(word);
    
    for (int i = 0; i < len; i++) {
        int target = word[i] - 'a';
        // Calculate clockwise and counterclockwise distances
        int clockwise = (target - current + 26) % 26;
        int counterclockwise = (current - target + 26) % 26;
        // Choose minimum distance
        int distance = min(clockwise, counterclockwise);
        time += distance + 1;  // Time to move + time to type
        current = target;
    }
    
    return time;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the word string

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for tracking position

✓ Linear Space

25.4K Views

Medium Frequency

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

Always Clockwise Movement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler