Longest Word in Dictionary Using Trie in DSA Typescript - Build from Scratch

Longest Word in Dictionary Using Trie

📖 Scenario: You are building a word game helper tool. You have a list of words and want to find the longest word that can be built one character at a time by other words in the list.For example, if the list contains "a", "ap", "app", "appl", "apple", and "apply", the longest word that can be built step-by-step is "apple" or "apply".

🎯 Goal: Build a Trie data structure to store the words. Then find the longest word in the dictionary where every prefix is also a word in the dictionary.

📋 What You'll Learn

Create a TrieNode class with children and endOfWord properties

Create a Trie class with insert and longestWord methods

Insert all words from the given list into the Trie

Find the longest word where all prefixes exist in the Trie

Print the longest valid word found

💡 Why This Matters

🌍 Real World

Tries are used in autocomplete systems, spell checkers, and word games to quickly find words and prefixes.

💼 Career

Understanding Tries and prefix-based searches is useful for software engineering roles involving search engines, text processing, and data indexing.

1

Create the TrieNode class

Create a class called TrieNode with a property children as a Map from string to TrieNode and a boolean property endOfWord initialized to false.

DSA Typescript

# Your code here

Hint

Think of TrieNode as a box that can hold links to other boxes (children) and a flag to say if a word ends here.

2

Create the Trie class and insert method

Create a class called Trie with a property root initialized as a new TrieNode. Add a method insert(word: string): void that inserts the given word into the Trie by creating nodes for each character and marking the last node's endOfWord as true.

DSA Typescript

class TrieNode {
    children: Map;
    endOfWord: boolean;

    constructor() {
        this.children = new Map();
        this.endOfWord = false;
    }
}

// Create the Trie class with root and insert method
# Your code here

Hint

Insert each character by moving down the Trie, creating new nodes if needed, and mark the end of the word.

3

Add longestWord method to find the longest valid word

Add a method longestWord(words: string[]): string to the Trie class. Insert all words into the Trie. Then find the longest word where every prefix is marked endOfWord in the Trie. Return the longest such word. If multiple words have the same length, return the lexicographically smallest.

DSA Typescript

class TrieNode {
    children: Map;
    endOfWord: boolean;

    constructor() {
        this.children = new Map();
        this.endOfWord = false;
    }
}

class Trie {
    root: TrieNode;

    constructor() {
        this.root = new TrieNode();
    }

    insert(word: string): void {
        let current = this.root;
        for (const char of word) {
            if (!current.children.has(char)) {
                current.children.set(char, new TrieNode());
            }
            current = current.children.get(char)!;
        }
        current.endOfWord = true;
    }

    // Add longestWord method below
    # Your code here
}

Hint

Use depth-first search starting from root. Only continue down nodes where endOfWord is true. Keep track of the longest valid word found.

4

Print the longest word found from the given list

Create a variable words with the exact list ["a", "ap", "app", "appl", "apple", "apply"]. Create a Trie instance called trie. Call trie.longestWord(words) and print the result using console.log.

DSA Typescript

class TrieNode {
    children: Map;
    endOfWord: boolean;

    constructor() {
        this.children = new Map();
        this.endOfWord = false;
    }
}

class Trie {
    root: TrieNode;

    constructor() {
        this.root = new TrieNode();
    }

    insert(word: string): void {
        let current = this.root;
        for (const char of word) {
            if (!current.children.has(char)) {
                current.children.set(char, new TrieNode());
            }
            current = current.children.get(char)!;
        }
        current.endOfWord = true;
    }

    longestWord(words: string[]): string {
        for (const word of words) {
            this.insert(word);
        }

        let longest = "";

        const dfs = (node: TrieNode, path: string): void => {
            if (path.length > longest.length || (path.length === longest.length && path  a[0].localeCompare(b[0]))) {
                if (child.endOfWord) {
                    dfs(child, path + char);
                }
            }
        };

        dfs(this.root, "");
        return longest;
    }
}

// Create words array, Trie instance, and print longest word
# Your code here

Hint

Use the longestWord method on the trie instance with the given words array and print the result.

Practice

1. What is the main purpose of using a Trie data structure when finding the longest word in a dictionary?

easy

A. To efficiently store and search words by their prefixes

B. To sort words alphabetically

C. To count the total number of words

D. To reverse the words quickly

Solution

1. Step 1: Understand Trie usage

   A Trie stores words by breaking them into characters and linking nodes for prefixes.

2. Step 2: Connect Trie to longest word search

   This structure allows quick prefix checks, which helps find the longest word built from other words.

3. Final Answer:

   To efficiently store and search words by their prefixes -> Option A

4. Quick Check:

   Trie = prefix search [OK]

Hint: Trie is best for prefix-based word searches [OK]

Common Mistakes:

• Thinking Trie sorts words alphabetically
• Confusing Trie with simple arrays
• Assuming Trie counts words only

2. Which of the following TypeScript code snippets correctly initializes a Trie node with children and an end-of-word flag?

easy

A. class TrieNode { children: Map = new Map(); isEnd: boolean = false; }

B. class TrieNode { children: string[] = []; isEnd: number = 0; }

C. class TrieNode { children: object = {}; isEnd: string = 'false'; }

D. class TrieNode { children: Map = new Map(); isEnd: boolean = true; }

Solution

1. Step 1: Check children type

   Children should map characters (string) to TrieNode objects, so Map is correct.

2. Step 2: Check isEnd flag type

   isEnd should be boolean to mark word end, so boolean = false is correct.

3. Final Answer:

   class TrieNode { children: Map = new Map(); isEnd: boolean = false; } -> Option A

4. Quick Check:

   Correct types = class TrieNode { children: Map = new Map(); isEnd: boolean = false; } [OK]

Hint: Use Map and boolean for TrieNode [OK]

Common Mistakes:

• Using array instead of Map for children
• Using wrong types for isEnd flag
• Mixing key and value types in Map

3. Given the following TypeScript code snippet that inserts words into a Trie and finds the longest word, what will be the output?

const words = ["a", "app", "apple", "apply", "ap"];
const trie = new Trie();
words.forEach(word => trie.insert(word));
console.log(trie.findLongestWord());

medium

A. "a"

B. "apply"

C. "apple"

D. "app"

Solution

1. Step 1: Insert words into Trie

   Words "a", "app", "apple", "apply", "ap" are inserted. Trie stores prefixes for all.

2. Step 2: Find longest word with all prefixes present

   "app" has all prefixes present: "a", "ap", "app". "apple" and "apply" require "appl" which is not a word in the list.

3. Final Answer:

   "app" -> Option D

4. Quick Check:

   Longest word with all prefixes = "app" [OK]

Hint: Choose longest word with all prefixes present, lex smallest if tie [OK]

Common Mistakes:

• Choosing "apple" or "apply" without checking if "appl" is a word
• Ignoring that intermediate prefixes like "appl" must be full words
• Picking the overall longest word without prefix validation

4. Consider this buggy TypeScript code snippet for inserting words into a Trie:

insert(word: string) {
  let node = this.root;
  for (const char of word) {
    node = node.children.get(char);
    if (!node.children.has(char)) {
      node.children.set(char, new TrieNode());
    }
  }
  node.isEnd = true;
}

What is the main issue causing a runtime error?

medium

A. The loop does not iterate over all characters

B. The isEnd flag is set before inserting nodes

C. node.children.get(char) can return undefined, causing node to be undefined

D. The children map is not initialized

Solution

1. Step 1: Analyze node update inside loop

   node.children.get(char) may return undefined if key missing, but code assumes it returns TrieNode.

2. Step 2: Identify cause of runtime error

   If undefined assigned to node, next iteration fails accessing children of undefined.

3. Final Answer:

   node.children.get(char) can return undefined, causing node to be undefined -> Option C

4. Quick Check:

   Undefined node from get() causes error [OK]

Hint: Check if get() can return undefined before assignment [OK]

Common Mistakes:

• Ignoring possibility of undefined from Map.get()
• Assuming loop skips characters
• Confusing isEnd flag placement

5. You have a list of words: ["w", "wo", "wor", "worl", "world", "banana", "ban", "bana", "banan"]. Using a Trie, which word will be the longest word in the dictionary where every prefix is also a word in the list?

hard

A. "banana"

B. "world"

C. "banan"

D. "worl"

Solution

1. Step 1: Check prefixes for "world"

   Prefixes: "w", "wo", "wor", "worl" all exist in list.

2. Step 2: Check prefixes for "banana" and "banan"

   "banana" and "banan" are missing shorter prefixes like "b" and "ba" which are not in the list.

3. Step 3: Compare valid longest words

   "world" is longest with all prefixes present; others longer but invalid.

4. Final Answer:

   "world" -> Option B

5. Quick Check:

   Longest word with all prefixes = "world" [OK]

Hint: Check all prefixes exist; longest valid word wins [OK]

Common Mistakes:

• Choosing "banana" ignoring missing prefix like "b"
• Confusing similar prefixes
• Not verifying all prefixes exist