Stack Concept and LIFO Principle in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Rust stack simulation?

Consider a stack where we push 1, then 2, then 3, and then pop once. What is the printed stack from top to bottom?

DSA Rust

let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
stack.pop();
println!("{:?}", stack);

A [1, 2, 3]

B [2, 3]

C [3, 2, 1]

D [1, 2]

💡 Hint

Remember that pop removes the last pushed item.

The stack pushes 1, 2, 3 in order. Pop removes 3, so stack has 1 and 2 left, printed as [1, 2].

🧠 Conceptual

intermediate

Which operation follows the LIFO principle in a stack?

Choose the operation that correctly follows the Last In First Out principle in a stack.

A Adding elements at the bottom

B Removing the first element added

C Removing the last element added

D Accessing elements randomly

💡 Hint

LIFO means the last item added is the first to be removed.

Stacks remove the most recently added element first, which is the last element pushed.

🔧 Debug

advanced

What error does this Rust stack code produce?

Analyze the code below and identify the error it causes when run.

DSA Rust

let mut stack = Vec::new();
stack.push(10);
stack.pop();
stack.pop();

A Compile-time error: cannot pop from empty vector

B None, runs successfully

C Panic: called `Option::unwrap()` on a `None` value

D Runtime error: index out of bounds

💡 Hint

Pop returns an Option; popping empty returns None but does not panic.

Calling pop on an empty vector returns None safely without panic or error.

🚀 Application

advanced

What is the stack content after these operations?

Given an empty stack, perform these operations in order: push 5, push 10, pop, push 7, push 3, pop. What is the stack content from top to bottom?

A 7 -> 5 -> null

B 3 -> 7 -> 5 -> null

C 10 -> 7 -> 5 -> null

D 5 -> 7 -> null

💡 Hint

Pop removes the last pushed item each time.

Operations: - push 5: stack 5 - push 10: stack 10,5 - pop: removes 10, stack 5 - push 7: stack 7,5 - push 3: stack 3,7,5 - pop: removes 3, stack 7,5 So top to bottom: 7 -> 5 -> null

❓ Predict Output

expert

What is the output of this Rust stack simulation with multiple pops?

Analyze the code and determine the final printed stack content.

DSA Rust

let mut stack = Vec::new();
stack.push(2);
stack.push(4);
stack.push(6);
stack.pop();
stack.push(8);
stack.pop();
stack.pop();
println!("{:?}", stack);

A [2]

B []

C [4]

D [2, 4]

💡 Hint

Track each push and pop carefully in order.

Operations: - push 2: [2] - push 4: [2,4] - push 6: [2,4,6] - pop: removes 6 -> [2,4] - push 8: [2,4,8] - pop: removes 8 -> [2,4] - pop: removes 4 -> [2] Final stack: [2]

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. First In, First Out - the first element added is the first to be removed

B. Last In, First Out - the first element added is the first to be removed

C. Last In, First Out - the last element added is the first to be removed

D. First In, Last Out - the first element added is the last to be removed

Solution

1. Step 1: Understand LIFO meaning

   LIFO means the last item added to the stack is the first one to be taken out.

2. Step 2: Match with options

   Last In, First Out - the last element added is the first to be removed correctly states "Last In, First Out" which matches the LIFO principle.

3. Final Answer:

   Last In, First Out - the last element added is the first to be removed -> Option C

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing up order of insertion and removal

2. Which of the following is the correct Rust syntax to push an element 10 onto a stack named stack?

easy

A. stack.push(10);

B. stack.add(10);

C. stack.insert(10);

D. stack.append(10);

Solution

1. Step 1: Recall Rust Vec stack push method

   In Rust, a stack is often implemented using a Vec, and pushing uses the push method.

2. Step 2: Check method names

   Only push is the correct method to add an element at the end of a Vec.

3. Final Answer:

   stack.push(10); -> Option A

4. Quick Check:

   Rust Vec push method = push() [OK]

Hint: Use push() to add elements to Rust Vec stack [OK]

Common Mistakes:

• Using add() which does not exist
• Using insert() without index
• Using append() which expects another collection

3. What will be the output of the following Rust code?

let mut stack = Vec::new();
stack.push(5);
stack.push(10);
let x = stack.pop();
println!("{:?}", x);

medium

A. Some(10)

B. 10

C. None

D. Some(5)

Solution

1. Step 1: Trace stack push operations

   Stack after pushes: [5, 10] (10 is last pushed)

2. Step 2: Trace pop operation

   Pop removes last element 10 and returns Some(10) because pop returns Option type.

3. Final Answer:

   Some(10) -> Option A

4. Quick Check:

   pop() returns Some(last element) = Some(10) [OK]

Hint: pop() returns Some(last pushed) or None if empty [OK]

Common Mistakes:

• Thinking pop returns raw value, not Option
• Confusing order of elements popped
• Expecting None instead of Some value

4. Identify the error in this Rust code snippet that tries to pop from an empty stack:

let mut stack: Vec<i32> = Vec::new();
let value = stack.pop().unwrap();
println!("{}", value);

medium

A. pop() method does not exist on Vec

B. Calling unwrap() on None causes panic

C. stack is not mutable

D. println! macro syntax is incorrect

Solution

1. Step 1: Understand pop() on empty Vec

   pop() returns None if Vec is empty.

2. Step 2: Effect of unwrap() on None

   Calling unwrap() on None causes a runtime panic (crash).

3. Final Answer:

   Calling unwrap() on None causes panic -> Option B

4. Quick Check:

   unwrap() on None = panic [OK]

Hint: Never unwrap pop() without checking if stack is empty [OK]

Common Mistakes:

• Assuming pop() always returns Some
• Ignoring mutability requirement
• Misreading println! syntax

5. Given a stack implemented as a Rust Vec, what will be the content of the stack after the following sequence of operations?

Operations:
1) push(1)
2) push(2)
3) pop()
4) push(3)
5) push(2)
6) pop()

hard

A. Stack after operations is [1, 2]

B. Stack after operations is [1, 2, 3]

C. Stack after operations is [1, 3, 2]

D. Stack after operations is [1, 3]

Solution

1. Step 1: Simulate each operation step-by-step

   Start: [] 1) push(1) -> [1] 2) push(2) -> [1, 2] 3) pop() removes 2 -> [1] 4) push(3) -> [1, 3] 5) push(2) -> [1, 3, 2] 6) pop() removes 2 -> [1, 3]

2. Step 2: Compare final stack with options

   Final stack is [1, 3], which matches Stack after operations is [1, 3].

3. Final Answer:

   Stack after operations is [1, 3] -> Option D

4. Quick Check:

   Trace pushes and pops carefully [OK]

Hint: Track pushes and pops stepwise to find final stack [OK]

Common Mistakes:

• Ignoring pop removes last pushed element
• Mixing order of push and pop
• Assuming pop removes first element