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

Understanding the Visualization

Input

Word to type on circular keyboard starting at 'a'

Process

For each character, choose shorter clockwise/counterclockwise path

Output

Minimum total seconds needed

Key Takeaway

🎯 Key Insight: Always choose the shorter path around the circle for each character transition

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

Approach	Time	Space	Notes
✓ Greedy Optimal Path Selection	O(n)	O(1)	For each character, choose the shorter of clockwise or counterclockwise path
Always Clockwise Movement	O(n)	O(1)	Move clockwise only, never considering counterclockwise path

Greedy Optimal Path Selection — Algorithm Steps

Start at position 'a'
For each character, calculate both clockwise and counterclockwise distances
Choose minimum distance and update position
Add movement time plus typing time

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Both

Compute clockwise and counterclockwise distances

Choose Minimum

Select shorter path around the circle

Optimal Result

Always gets minimum time

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 distance
        int clockwise = (target - current + 26) % 26;
        // Calculate counterclockwise distance
        int counterclockwise = (current - target + 26) % 26;
        
        // Choose minimum distance
        time += min(clockwise, counterclockwise);
        time += 1; // Time to type the character
        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 with constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using variables for current position and time counter

✓ 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

Greedy Optimal Path Selection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler