Peek Front Element of Queue in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to peek the front element of the queue using the correct method.

DSA Rust

let front = queue.[1]();

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

Apop_front

Bpeek

Cpeek_front

Dfront

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop_front removes the element instead of just peeking.

Using peek is not a method in VecDeque.

peek_front is not a valid method in Rust's VecDeque.

The front method returns a reference to the front element of the queue without removing it.

2fill in blank

medium

Complete the code to safely get the front element of the queue and handle the case when the queue is empty.

DSA Rust

if let Some(front) = queue.[1]() {
    println!("Front element: {}", front);
} else {
    println!("Queue is empty");
}

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

Apop_front

Bpeek

Cfront

Dget_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop_front removes the element.

Using peek or get_front are not valid methods.

Not handling the None case leads to runtime errors.

The front method returns an Option with a reference to the front element, allowing safe handling of empty queues.

3fill in blank

hard

Fix the error in the code to correctly print the front element of the queue.

DSA Rust

println!("Front element: {}", queue.[1]().unwrap());

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

Afront

Bpeek

Cpop_front

Dpeek_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using peek or peek_front are invalid methods.

Using pop_front removes the element.

Not using unwrap() on the Option causes a type mismatch.

The front method returns an Option, so calling unwrap() on it safely gets the front element if it exists.

4fill in blank

hard

Fill in the blank to create a function that returns the front element of the queue or None if empty.

DSA Rust

fn peek_front(queue: &VecDeque<i32>) -> Option<&i32> {
    queue.[1]()
}

let front = peek_front(&queue);
match front {
    Some(value) => println!("Front: {}", value),
    None => println!("Queue empty"),
}

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

Apop_front

Bfront

Cpeek

Dpeek_front

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop_front removes the element.

Using peek or peek_front are invalid methods.

Not returning an Option causes errors.

The front method returns an Option with a reference to the front element without removing it, perfect for this function.

5fill in blank

hard

Fill all three blanks to create a function that prints the front element or a message if the queue is empty.

DSA Rust

fn print_front(queue: &VecDeque<i32>) {
    match queue.[1]() {
        Some([2]) => println!("Front element: {}", [3]),
        None => println!("Queue is empty"),
    }
}

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

Apeek

Bfront

Cvalue

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Using invalid method names like peek.

Using different variable names in match and println!.

Using pop_front removes the element.

The front method returns an Option with a reference to the front element. The variable name can be any valid identifier, here value is used consistently.

Practice

1. What does the peek() method do in a queue data structure?

easy

A. Adds a new element to the back of the queue

B. Returns the front element without removing it

C. Removes the front element from the queue

D. Checks if the queue is empty

Solution

1. Step 1: Understand the purpose of peek()

   The peek() method is used to look at the front element of the queue without changing the queue.

2. Step 2: Differentiate peek() from other queue operations

   Unlike dequeue which removes the front element, peek() only returns it without removal.

3. Final Answer:

   Returns the front element without removing it -> Option B

4. Quick Check:

   peek() = front element [OK]

Hint: Peek means look without removing [OK]

Common Mistakes:

• Confusing peek() with dequeue()
• Thinking peek() adds elements
• Assuming peek() checks emptiness

2. Which of the following is the correct Rust syntax to peek the front element of a VecDeque named queue?

easy

A. let front = queue.front();

B. let front = queue.peek_front();

C. let front = queue.peek();

D. let front = queue[0];

Solution

1. Step 1: Recall VecDeque front method

   In Rust, VecDeque provides front() to look at the front element without removing it.

2. Step 2: Check other options

   peek_front() and peek() are not valid VecDeque methods; queue[0] is invalid because VecDeque does not implement Index<usize>.

3. Final Answer:

   let front = queue.front(); -> Option A

4. Quick Check:

   VecDeque peek front = front() [OK]

Hint: Use front() to peek front in VecDeque [OK]

Common Mistakes:

• Using peek_front() which does not exist on VecDeque
• Using peek() which does not exist
• Trying queue[0] without Index implementation

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

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(10);
    queue.push_back(20);
    queue.push_back(30);
    if let Some(front) = queue.front() {
        println!("{}", front);
    }
}

medium

A. 10

B. 20

C. 30

D. None

Solution

1. Step 1: Understand queue contents after push_back

   Elements added in order: 10 (front), 20, 30 (back).

2. Step 2: Peek front element

   front() returns reference to 10, the first element.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Front element = 10 [OK]

Hint: front() returns first pushed element [OK]

Common Mistakes:

• Confusing front() with pop_front()
• Expecting last element instead of first
• Ignoring Option handling with if let

4. Identify the error in this Rust code that tries to peek the front element of a queue:

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(5);
    let front = queue.peek();
    println!("{}", front.unwrap());
}

medium

A. Cannot unwrap Option returned by peek()

B. push_back() does not add elements

C. VecDeque has no method named peek()

D. println! macro syntax is incorrect

Solution

1. Step 1: Check VecDeque methods

   VecDeque does not have a method named peek(); it uses front() to peek front element.

2. Step 2: Analyze other parts

   push_back() correctly adds elements; unwrap() is valid if Option is Some; println! syntax is correct.

3. Final Answer:

   VecDeque has no method named peek() -> Option C

4. Quick Check:

   peek() method missing in VecDeque [OK]

Hint: Use front(), not peek(), on VecDeque [OK]

Common Mistakes:

• Using peek() instead of front()
• Ignoring method availability in VecDeque
• Assuming unwrap() always safe without checking

5. You have a queue implemented using VecDeque in Rust. You want to peek the front element safely and print it or print "Empty" if the queue is empty. Which code snippet correctly does this?

hard

A. if queue.is_empty() { println!("Empty"); } else { println!("{}", queue.pop_front().unwrap()); }

B. println!("{}", queue.front().unwrap());

C. println!("{}", queue[0]);

D. if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); }

Solution

1. Step 1: Understand safe peek usage

   front() returns Option<&T>. Using if let Some(front) safely handles empty queue.

2. Step 2: Check other options

   The unwrap version panics if empty (unsafe), direct indexing is invalid on VecDeque, the version with pop_front() removes the element instead of peeking.

3. Final Answer:

   if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); } -> Option D

4. Quick Check:

   Safe peek with if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); } [OK]

Hint: Use if let Some(front) = front() for safe peek [OK]

Common Mistakes:

• Unwrapping Option without checking
• Using pop_front() instead of front()
• Indexing VecDeque like a vector