Verifying an Alien Dictionary - Practice Coding Problems

Verifying an Alien Dictionary - Problem

Imagine you're working as a linguist studying an alien civilization that has just made contact with Earth. Surprisingly, these aliens use the same English lowercase letters as we do, but they've arranged their alphabet in a completely different order!

You've been given two crucial pieces of information:

A sequence of words written in this alien language
The order of their alphabet (a permutation of our 26 lowercase letters)

Your mission is to determine whether the given words are sorted lexicographically according to the alien alphabet order. In other words, would these words appear in the correct order in an alien dictionary?

For example: If the alien alphabet order is "hlabcdefgijkmnopqrstuvwxyz" (where 'h' comes before 'a'), then the word "hello" would come before "apple" in their dictionary, which is opposite to our English ordering!

Return true if the words are properly sorted according to the alien alphabet, false otherwise.

Input & Output

example_1.py — Basic Valid Case

$ Input: words = ["hello", "leetcode"], order = "hlabcdefgijkmnopqrstuvwxyz"

› Output: true

💡 Note: In the alien alphabet, 'h' comes before 'l', so 'hello' should come before 'leetcode'. The first differing characters are 'h' vs 'l', and since h is at position 0 and l is at position 1 in the alien order, this is correct.

example_2.py — Invalid Order Case

$ Input: words = ["word", "world", "row"], order = "worldabcefghijkmnpqstuvxyz"

› Output: false

💡 Note: The words are not sorted because 'world' should not come after 'word'. When comparing 'word' and 'world', all characters match until we reach the end of 'word'. Since 'word' is shorter, it should come first, but 'world' comes after it in the input, making this correct so far. However, 'world' vs 'row': 'w' comes after 'r' in the alien order, so 'row' should come before 'world'.

example_3.py — Single Character Difference

$ Input: words = ["apple", "app"], order = "abcdefghijklmnopqrstuvwxyz"

› Output: false

💡 Note: This is invalid because 'app' should come before 'apple' (shorter word comes first when one is a prefix of another), but in the given order 'apple' comes first.

Visualization

Tap to expand

Understanding the Visualization

Build Reference Guide

Create a position map for the alien alphabet: h→0, l→1, a→2, b→3, etc.

Compare Adjacent Books

Check each pair of adjacent words to ensure they follow the alien ordering

Find First Difference

For each word pair, find the first position where characters differ

Verify Order

Use the position map to check if the first word's character comes before the second word's character

Key Takeaway

🎯 Key Insight: We only need to compare adjacent word pairs, and for each pair, we find the first differing character position to determine the correct lexicographical order using the alien alphabet mapping.

Time & Space Complexity

Time Complexity

⏱️

O(N * M)

N is number of words, M is average word length. Hash map lookups are O(1)

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 character positions (constant space)

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
order.length == 26
All characters in words[i] and order are English lowercase letters
order is a permutation of the English lowercase letters

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 18

The optimal approach uses a hash map to preprocess the alien alphabet order, mapping each character to its position. Then we compare adjacent word pairs using O(1) character lookups, achieving O(N×M) time complexity where N is the number of words and M is the average word length. The key insight is that we only need to compare adjacent words and find the first differing character position to determine the correct lexicographical order.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map with Single Pass (Optimal)	O(N * M)	O(1)	Create position lookup table once, then verify order in single pass
Brute Force (Character-by-Character Comparison)	O(N * M * K)	O(1)	Compare every adjacent pair of words character by character without preprocessing

Hash Map with Single Pass (Optimal) — Algorithm Steps

Create a hash map mapping each character to its position in alien alphabet
For each pair of adjacent words, compare them using the position map
Compare characters from left to right using O(1) position lookups
If any adjacent pair is out of order, return false immediately
If all pairs are in correct order, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Position Map

Create hash map: h→0, l→1, a→2, b→3, c→4, ...

Fast Lookups

Use hash map for instant O(1) character position retrieval

Efficient Comparison

Compare adjacent words using fast position lookups

Code -

solution.c — C

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

int posMap[26];

void buildPosMap(const char* order) {
    for (int i = 0; order[i]; i++) {
        posMap[order[i] - 'a'] = i;
    }
}

bool compareWords(const char* word1, const char* word2) {
    int i = 0;
    int len1 = strlen(word1), len2 = strlen(word2);
    
    while (i < len1 && i < len2) {
        int pos1 = posMap[word1[i] - 'a'];
        int pos2 = posMap[word2[i] - 'a'];
        
        if (pos1 < pos2) return true;
        if (pos1 > pos2) return false;
        i++;
    }
    return len1 <= len2;
}

bool isAlienSorted(char words[][100], int wordCount, const char* order) {
    buildPosMap(order);
    
    for (int i = 0; i < wordCount - 1; i++) {
        if (!compareWords(words[i], words[i + 1])) {
            return false;
        }
    }
    return true;
}

int main() {
    // Input parsing and solution call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N * M)

N is number of words, M is average word length. Hash map lookups are O(1)

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 character positions (constant space)

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
order.length == 26
All characters in words[i] and order are English lowercase letters
order is a permutation of the English lowercase letters

125.0K Views

High Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map with Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler