Word Search in Trie in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a word into the Trie.

DSA Python

def insert_word(root, word):
    node = root
    for char in word:
        if char not in node.children:
            node.children[char] = [1]()
        node = node.children[char]
    node.is_end_of_word = True

Drag options to blanks, or click blank then click option'

Aset

Bdict

Clist

DTrieNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using a dictionary or list instead of a TrieNode object.

Not creating a new node when the character is missing.

We create a new TrieNode object for each new character path in the Trie.

2fill in blank

medium

Complete the code to search for a word in the Trie.

DSA Python

def search_word(root, word):
    node = root
    for char in word:
        if char not in node.children:
            return False
        node = node.children[[1]]
    return node.is_end_of_word

Drag options to blanks, or click blank then click option'

Achar

Bword

Cnode

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using the whole word or wrong variable to index children.

Using node or root instead of the character.

We use the current character 'char' to move down the Trie nodes.

3fill in blank

hard

Fix the error in the TrieNode class constructor to initialize children correctly.

DSA Python

class TrieNode:
    def __init__(self):
        self.children = [1]
        self.is_end_of_word = False

Drag options to blanks, or click blank then click option'

A[]

B{}

Cset()

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using a list or set instead of a dictionary.

Setting children to None which causes errors when accessing.

Children should be a dictionary to map characters to TrieNode children.

4fill in blank

hard

Fill both blanks to implement a function that checks if any word in the Trie starts with a given prefix.

DSA Python

def starts_with(root, prefix):
    node = root
    for char in prefix:
        if [1] not in node.children:
            return False
        node = node.children[[2]]
    return True

Drag options to blanks, or click blank then click option'

Achar

Bprefix

Cnode

Droot

Attempts:

3 left

💡 Hint

Common Mistakes

Using the whole prefix or wrong variable instead of the character.

Using node or root instead of the character.

We check if each character in prefix exists in children and move down using that character.

5fill in blank

hard

Fill all three blanks to implement a function that collects all words stored in the Trie.

DSA Python

def collect_words(node, prefix, words):
    if node.is_end_of_word:
        words.append([1])
    for char, child_node in node.children.items():
        collect_words(child_node, prefix [2] [3], words)

Drag options to blanks, or click blank then click option'

Aprefix

B+

Cchar

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Appending node or child_node instead of prefix.

Using subtraction or wrong operator instead of +.

Not adding the character to prefix during recursion.

We append the current prefix as a word, then recursively add characters to prefix using + operator.

Practice

1. What is the main purpose of using a Trie data structure in word search problems?

easy

A. To store words in a way that allows fast prefix-based search

B. To sort words alphabetically

C. To store words in a linked list

D. To compress words into a single string

Solution

1. Step 1: Understand the Trie structure

   A Trie stores characters of words in a tree-like structure where each node represents a character.

2. Step 2: Identify the main use in word search

   This structure allows quick lookup of words by their prefixes, making prefix-based search very efficient.

3. Final Answer:

   To store words in a way that allows fast prefix-based search -> Option A

4. Quick Check:

   Trie = fast prefix search [OK]

Hint: Trie is all about prefix search speed [OK]

Common Mistakes:

• Confusing Trie with sorting structures
• Thinking Trie stores words as linked lists
• Assuming Trie compresses words into strings

2. Which of the following is the correct way to check if a character ch exists as a child node in a Trie node's children dictionary named children?

easy

A. if ch in children.keys():

B. if children.has_key(ch):

C. if ch in children:

D. if children.contains(ch):

Solution

1. Step 1: Recall Python dictionary membership check

   In Python, to check if a key exists in a dictionary, use key in dict.

2. Step 2: Identify the correct syntax

   if ch in children: is the correct and most Pythonic way to check key existence.

3. Final Answer:

   if ch in children: -> Option C

4. Quick Check:

   Python dict key check = 'in' keyword [OK]

Hint: Use 'in' keyword to check dict keys in Python [OK]

Common Mistakes:

• Using deprecated has_key() method
• Checking keys() explicitly which is slower
• Using non-existent contains() method

3. Consider the following Python code snippet for searching a word in a Trie:

def search_word(root, word):
    node = root
    for ch in word:
        if ch not in node.children:
            return False
        node = node.children[ch]
    return node.is_end_of_word

# Trie nodes and root are properly initialized
result = search_word(root, 'cat')

If the Trie contains the words ['car', 'cat', 'cap'], what will be the value of result?

medium

A. None

B. False

C. KeyError

D. True

Solution

1. Step 1: Trace the search for 'cat'

   The function checks each character 'c', 'a', 't' in the Trie nodes. Since 'cat' is inserted, all characters exist and the last node marks end of word.

2. Step 2: Return the end of word flag

   Because 'cat' is a complete word in the Trie, node.is_end_of_word is True, so the function returns True.

3. Final Answer:

   True -> Option D

4. Quick Check:

   Word 'cat' found = True [OK]

Hint: If all chars found and end flag True, return True [OK]

Common Mistakes:

• Returning True without checking end_of_word flag
• Assuming partial prefix means word exists
• Confusing missing character with KeyError

4. The following code tries to search a word in a Trie but raises an error. Identify the bug:

def search_word(root, word):
    node = root
    for ch in word:
        if ch not in node:
            return False
        node = node[ch]
    return node.is_end_of_word

medium

A. Should use 'node.children[ch]' instead of 'node[ch]'

B. Both B and C are correct

C. Should check 'ch not in node.children' instead of 'ch not in node'

D. No bug, code is correct

Solution

1. Step 1: Analyze membership check

   The code checks if ch not in node, but node is an object, not a dictionary. It should check node.children.

2. Step 2: Analyze node traversal

   Similarly, node = node[ch] is incorrect; it should be node = node.children[ch] to access the child node.

3. Final Answer:

   Both B and C are correct -> Option B

4. Quick Check:

   Access children dict properly = Both fixes needed [OK]

Hint: Always access children dict, not node directly [OK]

Common Mistakes:

• Checking keys on node object instead of children dict
• Assigning node = node[ch] instead of node.children[ch]
• Ignoring attribute errors from wrong access

5. You want to find if any word in a Trie starts with a given prefix prefix. Which modification to the standard word search function below will correctly check for prefix existence?

def starts_with(root, prefix):
    node = root
    for ch in prefix:
        if ch not in node.children:
            return False
        node = node.children[ch]
    # What to return here?

hard

A. Return True immediately after loop ends

B. Return node.is_end_of_word

C. Return False if node has no children

D. Return True only if prefix length is 1

Solution

1. Step 1: Understand prefix search logic

   To check if any word starts with the prefix, we only need to confirm all prefix characters exist in the Trie.

2. Step 2: Decide return value after loop

   If all characters are found, return True immediately. We do not need to check if the node marks end of a word.

3. Final Answer:

   Return True immediately after loop ends -> Option A

4. Quick Check:

   Prefix found = True [OK]

Hint: If prefix chars found, return True regardless of word end [OK]

Common Mistakes:

• Returning is_end_of_word which fails for prefixes not full words
• Checking children existence unnecessarily
• Restricting prefix length to 1