Trie Node Design and Initialization in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a struct for a Trie node with a children field and an is_end field.

DSA Rust

struct TrieNode {
    children: Vec<Option<Box<TrieNode>>>[1]
}

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

A;

B, is_end: bool,

C,

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to include the is_end field.

Using a semicolon instead of a comma after the field.

The TrieNode struct requires a 'children' field and an 'is_end: bool' field to mark the end of words. Choose the option that properly adds the is_end field with correct syntax.

2fill in blank

medium

Complete the code to initialize the children vector with None values for each child.

DSA Rust

impl TrieNode {
    fn new() -> Self {
        TrieNode {
            children: vec![[1]; 26],
            is_end: false,
        }
    }
}

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

ASome(Box::new(TrieNode::new()))

BOption::None

CBox::new(None)

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using Some(...) instead of None, which creates unnecessary nodes.

Using Box::new(None) which is invalid.

Each child is initially None, meaning no child node exists yet. So we fill the vector with None.

3fill in blank

hard

Fix the error in the method signature to correctly define a new TrieNode constructor.

DSA Rust

impl TrieNode {
    fn new[1] -> Self {
        TrieNode {
            children: vec![None; 26],
            is_end: false,
        }
    }
}

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

A(mut self)

B(self)

C()

D(&self)

Attempts:

3 left

💡 Hint

Common Mistakes

Adding self or &self as a parameter to a static method.

Forgetting parentheses entirely.

The new method is a static constructor and takes no parameters, so it should have empty parentheses ().

4fill in blank

hard

Fill both blanks to define a method that checks if a node has a child at a given index.

DSA Rust

impl TrieNode {
    fn has_child(&self, index: usize) -> bool {
        self.children[[1]].[2]()
    }
}

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

Aindex

Bis_some

Cis_none

Dlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using is_none() which returns true if no child exists.

Using len() which is not a method on Option.

We check if the child at the given index exists by calling is_some() on the Option.

5fill in blank

hard

Fill all three blanks to define a method that inserts a child node at a given index.

DSA Rust

impl TrieNode {
    fn insert_child(&mut self, index: usize) {
        self.children[[1]] = Some(Box::new(TrieNode[2]));
        self.children[[3]].as_mut().unwrap().is_end = false;
    }
}

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

Aindex

B::new()

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed index like 0 or 1 instead of the parameter.

Forgetting to call new() to create the node.

We insert a new child at the given index by creating a new TrieNode with new(), then set is_end to false on that child.

Practice

1. What is the main purpose of a Trie node in a Trie data structure?

easy

A. To store characters and links to child nodes representing prefixes

B. To store integer values for sorting

C. To hold a single string only

D. To act as a queue for BFS traversal

Solution

1. Step 1: Understand Trie node role

   A Trie node stores a character and links to child nodes representing possible next characters in words.

2. Step 2: Compare options

   Only To store characters and links to child nodes representing prefixes correctly describes this role; others describe unrelated data structures or uses.

3. Final Answer:

   To store characters and links to child nodes representing prefixes -> Option A

4. Quick Check:

   Trie node = character + children links [OK]

Hint: Trie nodes hold characters and children links [OK]

Common Mistakes:

• Thinking Trie nodes store whole words
• Confusing Trie nodes with arrays or queues
• Assuming Trie nodes store integer values

2. Which Rust syntax correctly declares a Trie node struct with a children array of size 26 and a boolean flag for word end?

easy

A. struct TrieNode { children: [Option; 26], is_end: bool }

B. struct TrieNode { children: Vec<TrieNode>, is_end: bool }

C. struct TrieNode { children: [TrieNode; 26], is_end: bool }

D. struct TrieNode { children: Option, is_end: bool }

Solution

1. Step 1: Understand Rust struct for Trie node

   Each child is an optional boxed TrieNode to allow recursive structure with fixed size array of 26 for letters.

2. Step 2: Analyze options

   struct TrieNode { children: [Option; 26], is_end: bool } uses [Option; 26] which is correct. struct TrieNode { children: Vec<TrieNode>, is_end: bool } uses Vec which is dynamic, not fixed size. struct TrieNode { children: [TrieNode; 26], is_end: bool } uses [TrieNode; 26] which causes infinite size error. struct TrieNode { children: Option, is_end: bool } has only one Option not an array.

3. Final Answer:

   struct TrieNode { children: [Option; 26], is_end: bool } -> Option A

4. Quick Check:

   Use Option array for children [OK]

Hint: Use Option array for recursive children [OK]

Common Mistakes:

• Using Vec instead of fixed-size array
• Using direct TrieNode array causing infinite size
• Not wrapping children in Option<Box>

3. Given this Rust code snippet for TrieNode initialization, what will be the output of printing the is_end flag of the root node?

struct TrieNode {
    children: [Option; 26],
    is_end: bool,
}

impl TrieNode {
    fn new() -> Self {
        Self {
            children: Default::default(),
            is_end: false,
        }
    }
}

fn main() {
    let root = TrieNode::new();
    println!("{}", root.is_end);
}

medium

A. Runtime panic

B. true

C. Compilation error

D. false

Solution

1. Step 1: Analyze TrieNode::new() initialization

   The new() function sets is_end to false explicitly and children to default (None for each child).

2. Step 2: Check main output

   Printing root.is_end will print false as initialized.

3. Final Answer:

   false -> Option D

4. Quick Check:

   is_end initialized false = false [OK]

Hint: Default is_end is false unless set true [OK]

Common Mistakes:

• Assuming is_end defaults to true
• Expecting compilation error due to Default::default()
• Thinking children initialization affects is_end

4. Identify the error in this Rust TrieNode initialization code:

struct TrieNode {
    children: [Option; 26],
    is_end: bool,
}

impl TrieNode {
    fn new() -> Self {
        Self {
            children: [None; 26],
            is_end: false,
        }
    }
}

medium

A. is_end should be true by default

B. Cannot initialize array of Option with [None; 26]

C. Missing lifetime annotations for Box

D. Struct fields are private and inaccessible

Solution

1. Step 1: Understand array initialization in Rust

   Arrays of non-Copy types cannot be initialized with [value; size] unless value implements Copy.

2. Step 2: Check Option Copy trait

   Option does not implement Copy, so [None; 26] causes compilation error.

3. Final Answer:

   Cannot initialize array of Option with [None; 26] -> Option B

4. Quick Check:

   Non-Copy array init with [None; 26] fails [OK]

Hint: Use Default::default() for arrays of non-Copy types [OK]

Common Mistakes:

• Assuming [None; 26] works for Option<Box>
• Confusing lifetime errors with initialization errors
• Thinking is_end default must be true

5. You want to design a TrieNode in Rust that supports Unicode characters beyond just 'a' to 'z'. Which design change is best to handle this efficiently?

hard

A. Store children as a linked list of TrieNodes

B. Increase array size to 256 to cover all ASCII characters

C. Replace fixed-size array with a HashMap for children

D. Use Vec> with 26 elements

Solution

1. Step 1: Understand Unicode character range

   Unicode has many characters beyond ASCII; fixed arrays for 26 or 256 are inefficient or insufficient.

2. Step 2: Evaluate data structure options

   HashMap allows dynamic keys for any Unicode char efficiently. Increasing array size wastes memory. Vec with 26 elements limits to 26 chars. Linked list is inefficient for lookups.

3. Final Answer:

   Replace fixed-size array with a HashMap for children -> Option C

4. Quick Check:

   Use HashMap for Unicode children [OK]

Hint: Use HashMap for flexible Unicode children [OK]

Common Mistakes:

• Assuming fixed arrays can cover Unicode
• Using Vec with fixed size for Unicode
• Choosing linked list causing slow lookups