Keyboard Row - Practice Coding Problems

Keyboard Row - Problem

Keyboard Row Challenge

Imagine you're typing on a traditional QWERTY keyboard and want to find words that can be typed using letters from only one row of the keyboard. This is a common typing optimization problem!

Given an array of strings words, your task is to return all words that can be typed using letters from only one row of the American keyboard.

The American keyboard has three rows:
• First row: "qwertyuiop"
• Second row: "asdfghjkl"
• Third row: "zxcvbnm"

Note: The comparison is case-insensitive - both 'A' and 'a' are treated as the same letter from the second row.

Goal: Return an array containing only the words that can be typed using keys from a single keyboard row.

Input & Output

example_1.py — Basic Mixed Case

$ Input: ["Hello", "Alaska", "Dad", "Peace"]

› Output: ["Alaska", "Dad"]

💡 Note: "Alaska" can be typed using only the second row (asdfghjkl), and "Dad" can be typed using only the second row as well. "Hello" requires multiple rows (h from row 2, e from row 1, l from row 2, o from row 1), and "Peace" also requires multiple rows.

example_2.py — Single Characters

$ Input: ["omk"]

› Output: []

💡 Note: "omk" cannot be typed with one row: 'o' is in row 1 (qwertyuiop), 'm' is in row 3 (zxcvbnm), and 'k' is in row 2 (asdfghjkl). Since characters span across all three rows, it's not included in the result.

example_3.py — All Same Row

$ Input: ["adsdf", "sfd"]

› Output: ["adsdf", "sfd"]

💡 Note: Both words can be typed using only the second row (asdfghjkl). All characters 'a', 'd', 's', 'd', 'f' belong to the second row, so both words are included in the result.

Constraints

1 ≤ words.length ≤ 20
1 ≤ words[i].length ≤ 100
words[i] consists of English letters (both lowercase and uppercase)
Case-insensitive: 'A' and 'a' are treated as the same character

Visualization

Tap to expand

Understanding the Visualization

Create Zone Map

Build a directory mapping each letter to its keyboard row zone

Check First Letter

For each word, identify which zone the first letter belongs to

Verify Consistency

Ensure all remaining letters in the word belong to the same zone

Collect Results

Add words that pass the single-zone test to the final result

Key Takeaway

🎯 Key Insight: By creating a character-to-row mapping once, we can classify any word in O(word_length) time with O(1) space complexity, making this approach optimal for the keyboard row problem.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 Apple 6

The optimal approach uses a hash map to create a character-to-row mapping in O(1) space. For each word, we determine the row of the first character and verify all other characters belong to the same row. This achieves O(n×m) time complexity where n is the number of words and m is the average word length, making it much more efficient than the brute force O(n×m×k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map (Optimal)	O(n*m)	O(1)	Create character-to-row mapping once, then check each word in one pass
Brute Force (Nested Loops)	O(nmk)	O(1)	Check each word against each keyboard row character by character

Hash Map (Optimal) — Algorithm Steps

Create a hash map mapping each character to its row number (0, 1, or 2)
For each word in the input array:
Convert word to lowercase for case-insensitive comparison
Get the row number of the first character
Check if all remaining characters belong to the same row
If yes, add word to result; if no, skip to next word

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

Create mapping from each character to its row number

Check First Character

Determine which row the word should belong to

Validate Remaining

Verify all other characters belong to the same row

Code -

solution.c — C

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

char** findWords(char** words, int wordsSize, int* returnSize) {
    // Create character to row mapping array
    int charToRow[26];
    char* rows[] = {"qwertyuiop", "asdfghjkl", "zxcvbnm"};
    
    // Initialize mapping
    for (int r = 0; r < 3; r++) {
        int len = strlen(rows[r]);
        for (int i = 0; i < len; i++) {
            charToRow[rows[r][i] - 'a'] = r;
        }
    }
    
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        if (strlen(words[i]) == 0) continue;
        
        int wordLen = strlen(words[i]);
        int firstRow = charToRow[tolower(words[i][0]) - 'a'];
        int sameRow = 1;
        
        for (int j = 1; j < wordLen; j++) {
            if (charToRow[tolower(words[i][j]) - 'a'] != firstRow) {
                sameRow = 0;
                break;
            }
        }
        
        if (sameRow) {
            result[*returnSize] = (char*)malloc((wordLen + 1) * sizeof(char));
            strcpy(result[*returnSize], words[i]);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"Hello", "Alaska", "Dad", "Peace"};
    int returnSize;
    char** result = findWords(words, 4, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(", ");
        printf("\"%s\"", result[i]);
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

n words × m average word length, with O(1) hash map lookups

✓ Linear Growth

Space Complexity

O(1)

Hash map contains at most 26 characters (constant space)

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler