Peek Top Element of Stack in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to peek the top element of the stack safely.

DSA Rust

fn peek(stack: &Vec<i32>) -> Option<&i32> {
    stack.[1]()
}

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

Apop

Bremove

Cget

Dlast

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() removes the element, but peek should not remove it.

Using get() requires an index, which is not needed here.

The last() method returns an Option with a reference to the last element, which is the top of the stack.

2fill in blank

medium

Complete the code to peek the top element and handle empty stack with unwrap_or.

DSA Rust

fn peek_or_default(stack: &Vec<i32>) -> i32 {
    *stack.[1]().unwrap_or(&0)
}

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

Alast

Bfirst

Cpop

Dget

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() removes the element.

Using first() returns the first element, not the last.

last() returns an Option<&i32>. Using unwrap_or(&0) returns a reference to 0 if empty, then dereferenced to i32.

3fill in blank

hard

Fix the error in the peek function to return the top element correctly.

DSA Rust

fn peek(stack: &Vec<i32>) -> Option<i32> {
    stack.[1]().copied()
}

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

Aremove

Blast

Cget

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() removes the element.

Not using copied() causes a type mismatch.

last() returns Option<&i32>. Using copied() converts it to Option by copying the value.

4fill in blank

hard

Fill both blanks to peek the top element and print it if present.

DSA Rust

fn print_top(stack: &Vec<i32>) {
    if let Some(top) = stack.[1]() {
        println!("Top element: {}", [2]top);
    }
}

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

Alast

Bpop

C*

D&

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() removes the element.

Using & instead of * will print the reference address.

last() returns Option<&i32>. To print the value, dereference with *.

5fill in blank

hard

Fill all three blanks to peek the top element, double it, and return the result or zero if empty.

DSA Rust

fn double_top(stack: &Vec<i32>) -> i32 {
    stack.[1]().map(|x| *x[2]2).unwrap_or([3])
}

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

Alast

B*

C0

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() removes the element.

Using + instead of * changes the operation.

Not handling empty stack with unwrap_or.

last() returns Option<&i32>. map(|x| *x * 2) doubles the value. unwrap_or(0) returns 0 if empty.

Practice

1. What does the peek operation do in a stack data structure?

easy

A. Returns the top element without removing it

B. Removes the top element and returns it

C. Adds a new element to the top

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack operations

   A stack stores elements in a last-in, first-out order. Common operations include push, pop, and peek.

2. Step 2: Define peek operation

   Peek returns the top element without removing it, allowing you to see the current top value safely.

3. Final Answer:

   Returns the top element without removing it -> Option A

4. Quick Check:

   Peek = top element without removal [OK]

Hint: Peek shows top without changing stack [OK]

Common Mistakes:

• Confusing peek with pop operation
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following Rust code snippets correctly peeks the top element of a stack implemented as a Vec<i32> named stack?

easy

A. let top = stack.last();

B. let top = stack[0];

C. let top = stack.pop();

D. let top = stack.first();

Solution

1. Step 1: Understand Rust Vec methods for stack

   In Rust, Vec can be used as a stack. pop() removes and returns the last element, last() returns a reference to the last element without removing it.

2. Step 2: Identify correct peek method

   Peek means to see the top element without removing it, so stack.last() is correct. stack.pop() removes it, stack[0] accesses the first element, and stack.first() returns the first element, not the top.

3. Final Answer:

   let top = stack.last(); -> Option A

4. Quick Check:

   Peek = stack.last() [OK]

Hint: Use .last() to peek top element in Rust Vec stack [OK]

Common Mistakes:

• Using pop() which removes element
• Accessing first() instead of last()
• Using index 0 which is bottom of stack

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

let mut stack = vec![10, 20, 30];
if let Some(top) = stack.last() {
    println!("{}", top);
} else {
    println!("Stack is empty");
}

medium

A. 20

B. 30

C. 10

D. Stack is empty

Solution

1. Step 1: Understand stack contents and last()

   The stack vector contains [10, 20, 30]. The last element is 30.

2. Step 2: Trace the if let statement

   The stack.last() returns Some(&30), so the if block prints 30.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   stack.last() = 30 [OK]

Hint: stack.last() returns top element reference [OK]

Common Mistakes:

• Printing bottom element instead of top
• Confusing last() with pop() output
• Assuming stack is empty

4. Identify the error in the following Rust code that tries to peek the top element of a stack and fix it:

let stack = vec![1, 2, 3];
let top = stack.pop().unwrap();
println!("Top element: {}", top);

medium

A. No error, code works correctly

B. pop() removes element; use last() to peek instead

C. unwrap() causes panic; use expect() instead

D. stack should be mutable to use pop()

Solution

1. Step 1: Check mutability for pop()

   pop() removes the last element, so the vector must be mutable. Here, stack is immutable.

2. Step 2: Fix by making stack mutable

   Change let stack = vec![1, 2, 3]; to let mut stack = vec![1, 2, 3]; to allow pop().

3. Final Answer:

   stack should be mutable to use pop() -> Option D

4. Quick Check:

   pop() needs mutable stack [OK]

Hint: pop() requires mutable stack variable [OK]

Common Mistakes:

• Ignoring mut keyword error
• Confusing pop() with peek operation
• Assuming unwrap() always safe

5. Given a stack implemented as Vec<i32>, write a Rust function peek_top that returns the top element as Option<i32> without removing it. What is the correct implementation?

hard

A. fn peek_top(stack: &mut Vec<i32>) -> Option<i32> { stack.pop() }

B. fn peek_top(stack: &Vec<i32>) -> i32 { *stack.last().unwrap() }

C. fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() }

D. fn peek_top(stack: Vec<i32>) -> Option<i32> { stack.first().copied() }

Solution

1. Step 1: Understand function requirements

   The function must peek without removing, so it should borrow stack immutably and return Option<i32>.

2. Step 2: Analyze options

   fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() } uses stack.last().copied() which returns Option<i32> by copying the reference. fn peek_top(stack: &mut Vec<i32>) -> Option<i32> { stack.pop() } removes element (pop), fn peek_top(stack: &Vec<i32>) -> i32 { *stack.last().unwrap() } unwraps and returns i32 (not Option), fn peek_top(stack: Vec<i32>) -> Option<i32> { stack.first().copied() } uses first() which is bottom element.

3. Final Answer:

   fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() } -> Option C

4. Quick Check:

   Peek returns Option with copied last element [OK]

Hint: Use last().copied() for safe peek returning Option<i32> [OK]

Common Mistakes:

• Using pop() which removes element
• Returning i32 instead of Option<i32>
• Accessing first() instead of last()