Alphabet Board Path - Practice Coding Problems

Alphabet Board Path - Problem

Navigate the Alphabet Board!

Imagine you have a virtual keyboard laid out as a grid where each letter of the alphabet occupies a specific position. Your task is to navigate this board and spell out any given word by moving from letter to letter.

The alphabet board looks like this:

a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
z

You start at position (0, 0) which contains the letter 'a'. You can move in four directions:
• 'U' - Move up one row
• 'D' - Move down one row
• 'L' - Move left one column
• 'R' - Move right one column
• '!' - Select the current letter

Your goal is to return a sequence of moves that spells out the target word using the minimum number of moves. Note that you can only move to positions that actually contain letters (so be careful with 'z' which is alone on the bottom row!).

Input & Output

example_1.py — Basic Word

$ Input: target = "leet"

› Output: "DDR!UURRR!DDDR!UUL!"

💡 Note: Starting at 'a' (0,0): Go to 'l' (2,1) with DD R!, then to first 'e' (0,4) with UU RRR!, then to second 'e' (0,4) already there!, then to 't' (3,4) with DDD R!, then to 't' (3,3) with U L!

example_2.py — Single Character

$ Input: target = "code"

› Output: "RR!R!DD!"

💡 Note: From 'a' to 'c': RR!, from 'c' to 'o': DDRR!, from 'o' to 'd': UUL!, from 'd' to 'e': R!

example_3.py — Edge Case with Z

$ Input: target = "zdz"

› Output: "DDDDD!UUUUURRRRR!LLLLLDDDDDD!"

💡 Note: From 'a' to 'z': DDDDD! (down 5 rows), from 'z' to 'd': UUUUR! (up first to avoid bounds, then right), from 'd' to 'z': LLLLLDDDDD! (left first, then down to 'z')

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

Create a coordinate system where each letter has a fixed (row, col) position

Plan the Route

For each target character, calculate the shortest Manhattan distance path

Handle Edge Cases

Special navigation rules for 'z' since it's isolated on the bottom row

Execute Moves

Generate the sequence of U/D/L/R moves and '!' selections

Key Takeaway

🎯 Key Insight: Transform the problem into coordinate geometry with pre-computed positions for O(1) lookup, handle the 'z' edge case with proper move ordering to avoid out-of-bounds positions.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each character in target string once, with O(1) lookup per character

✓ Linear Growth

Space Complexity

O(26)

Hash map to store coordinates of all 26 letters

✓ Linear Space

Constraints

1 ≤ target.length ≤ 100
target consists only of English lowercase letters
The board layout is fixed as shown: ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"]
Special constraint: 'z' is the only character on the 6th row, so movement must be carefully ordered

Asked in

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

The optimal solution uses coordinate mapping with a hash table to pre-compute each character's position, enabling O(1) lookups. The key insight is calculating Manhattan distance between positions while carefully handling the 'z' edge case by moving up/left first when leaving the bottom row. Time complexity: O(n), Space complexity: O(26).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character Search)	O(n × 26)	O(1)	Search for each character position by scanning the entire board
Coordinate Mapping (Optimal)	O(n)	O(26)	Pre-compute character positions and calculate Manhattan distances

Brute Force (Character-by-Character Search) — Algorithm Steps

For each character in target string
Scan the entire 6x5 board to find character position
Calculate Manhattan distance from current position
Generate move sequence (handle 'z' edge case)
Add '!' to select the character
Update current position

Visualization

Tap to expand

Step-by-Step Walkthrough

Search for 'l'

Scan entire board to find 'l' at position (2,0)

Calculate moves

From (0,0) to (2,0): need 2 down moves

Generate path

Add 'DD!' to result string

Code -

solution.c — C

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

typedef struct {
    int r, c;
} Position;

Position findPosition(char board[][6], char ch) {
    char* rows[] = {"abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"};
    for (int r = 0; r < 6; r++) {
        for (int c = 0; c < strlen(rows[r]); c++) {
            if (rows[r][c] == ch) {
                return (Position){r, c};
            }
        }
    }
    return (Position){-1, -1};
}

char* alphabetBoardPath(char* target) {
    char board[6][6];
    char* result = (char*)malloc(10000 * sizeof(char));
    int idx = 0;
    
    int currR = 0, currC = 0; // Start at 'a'
    
    for (int i = 0; target[i]; i++) {
        Position pos = findPosition(board, target[i]);
        int targetR = pos.r, targetC = pos.c;
        
        // Handle 'z' edge case
        if (target[i] == 'z') {
            while (currC > targetC) {
                result[idx++] = 'L';
                currC--;
            }
            while (currR < targetR) {
                result[idx++] = 'D';
                currR++;
            }
        } else {
            while (currR > targetR) {
                result[idx++] = 'U';
                currR--;
            }
            while (currC < targetC) {
                result[idx++] = 'R';
                currC++;
            }
            while (currC > targetC) {
                result[idx++] = 'L';
                currC--;
            }
            while (currR < targetR) {
                result[idx++] = 'D';
                currR++;
            }
        }
        
        result[idx++] = '!';
    }
    
    result[idx] = '\0';
    return result;
}

int main() {
    char target[1000];
    fgets(target, sizeof(target), stdin);
    // Remove newline and quotes
    target[strcspn(target, "\n")] = 0;
    if (target[0] == '"') {
        memmove(target, target+1, strlen(target));
        target[strlen(target)-1] = '\0';
    }
    char* result = alphabetBoardPath(target);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 26)

For each character in target (n), we scan up to 26 positions on the board

✓ Linear Growth

Space Complexity

O(1)

Only using variables for current position and result string

✓ Linear Space

Constraints

1 ≤ target.length ≤ 100
target consists only of English lowercase letters
The board layout is fixed as shown: ["abcde", "fghij", "klmno", "pqrst", "uvwxy", "z"]
Special constraint: 'z' is the only character on the 6th row, so movement must be carefully ordered

23.1K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Character-by-Character Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler