Single-Row Keyboard - Practice Coding Problems

Single-Row Keyboard - Problem

Imagine a futuristic keyboard where all 26 letters are arranged in a single horizontal row instead of the traditional QWERTY layout. You're a one-finger typist (like many of us on mobile phones!) and need to calculate the total time required to type a word.

Given:

A string keyboard of length 26 representing the custom layout (each letter appears exactly once)
A string word that you want to type

Rules:

Your finger starts at position 0 (the first key)
To type any character, you must move your finger to that character's position
The time to move from position i to position j is |i - j|

Goal: Return the minimum time needed to type the entire word.

Example: If keyboard = "abcdefghijklmnopqrstuvwxyz" and word = "cba", you'd move: 0→2 (cost 2), 2→1 (cost 1), 1→0 (cost 1) = total time of 4.

Input & Output

example_1.py — Basic Example

$ Input: keyboard = "abcdefghijklmnopqrstuvwxyz", word = "cba"

› Output: 4

💡 Note: Starting at position 0: move to 'c' at position 2 (cost 2), then to 'b' at position 1 (cost 1), then to 'a' at position 0 (cost 1). Total: 2+1+1 = 4.

example_2.py — Custom Keyboard Layout

$ Input: keyboard = "pqrstuvwxyzabcdefghijklmno", word = "leetcode"

› Output: 73

💡 Note: With this custom layout, characters are in different positions. We calculate the distance for each character move: l→e→e→t→c→o→d→e, summing all the absolute differences between consecutive positions.

example_3.py — Single Character

$ Input: keyboard = "abcdefghijklmnopqrstuvwxyz", word = "z"

› Output: 25

💡 Note: Edge case with single character. Starting at position 0, we need to move to 'z' at position 25, so the total time is |0-25| = 25.

Constraints

keyboard.length == 26
keyboard contains each English lowercase letter exactly once in some order
1 ≤ word.length ≤ 10⁴
word[i] is a lowercase English letter

Visualization

Tap to expand

Understanding the Visualization

Initialize

Place finger at starting position (index 0) on the keyboard

Lookup Position

Use hash table to instantly find the target character's position

Calculate Distance

Compute absolute difference between current and target positions

Move Finger

Add the distance to total time and update current position

Repeat

Continue for each character in the word

Key Takeaway

🎯 Key Insight: Instead of searching through the keyboard repeatedly, create a hash table once to enable instant O(1) character position lookups, reducing time complexity from O(n×26) to O(n).

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal solution uses a hash table to map each character to its keyboard position, achieving O(n) time complexity. Instead of searching through the 26-character keyboard for each letter (which would be O(n×26)), we build the position map once in O(26) time, then process the word with O(1) character lookups. This approach is both time and space efficient, making it ideal for interview scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table Optimization (Optimal)	O(n)	O(1)	Build position map once, then lookup character positions in O(1) time
Brute Force (Linear Search)	O(n*m)	O(1)	Search for each character's position in the keyboard string every time

Hash Table Optimization (Optimal) — Algorithm Steps

Create a hash map mapping each character to its index in keyboard
Initialize current position to 0 and total time to 0
For each character in word, lookup its position in O(1) time
Calculate distance from current position and add to total time
Update current position to the character's position

Visualization

Tap to expand

Step-by-Step Walkthrough

Build hash map

Create mapping of each character to its keyboard position

Process word efficiently

For each character, instantly lookup position and calculate distance

No repeated searches

Each character lookup is O(1) instead of O(26)

Code -

solution.c — C

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

int calculateTime(char* keyboard, char* word) {
    // Build position array for O(1) lookups (using ASCII values)
    int charPositions[128]; // ASCII table size
    memset(charPositions, -1, sizeof(charPositions));
    
    int keyboardLen = strlen(keyboard);
    for (int i = 0; i < keyboardLen; i++) {
        charPositions[(int)keyboard[i]] = i;
    }
    
    int totalTime = 0;
    int currentPos = 0;
    int wordLen = strlen(word);
    
    for (int i = 0; i < wordLen; i++) {
        // O(1) lookup instead of O(26) search
        int targetPos = charPositions[(int)word[i]];
        // Calculate distance and add to total
        int distance = currentPos - targetPos;
        if (distance < 0) distance = -distance;
        totalTime += distance;
        // Update current position
        currentPos = targetPos;
    }
    
    return totalTime;
}

int main() {
    char keyboard[100], word[100];
    fgets(keyboard, sizeof(keyboard), stdin);
    fgets(word, sizeof(word), stdin);
    
    // Remove newlines and quotes
    keyboard[strcspn(keyboard, "\n")] = 0;
    word[strcspn(word, "\n")] = 0;
    if (keyboard[0] == '"') memmove(keyboard, keyboard+1, strlen(keyboard));
    if (keyboard[strlen(keyboard)-1] == '"') keyboard[strlen(keyboard)-1] = 0;
    if (word[0] == '"') memmove(word, word+1, strlen(word));
    if (word[strlen(word)-1] == '"') word[strlen(word)-1] = 0;
    
    printf("%d\n", calculateTime(keyboard, word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(26) to build hash map + O(n) to process word = O(n) overall

✓ Linear Growth

Space Complexity

O(1)

Hash map stores 26 character positions, which is constant space O(26) = O(1)

✓ Linear Space

23.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Hash Table Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler