Check if Stack is Empty or Full in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if the stack is empty.

DSA Rust

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

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

Ais_empty

Blen

Cis_full

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using len() instead of is_empty() returns a number, not a boolean.

Using pop() removes an element instead of checking emptiness.

The is_empty() method returns true if the stack has no elements.

2fill in blank

medium

Complete the code to check if the stack is full given its capacity.

DSA Rust

fn is_full(stack: &Vec<i32>, capacity: usize) -> bool {
    stack.len() == [1]
}

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

Acapacity

Bstack.len()

C0

Dstack.capacity()

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing length to zero instead of capacity.

Using stack.capacity() which is the allocated size, not the logical capacity.

The stack is full when its current length equals its capacity.

3fill in blank

hard

Fix the error in the function that checks if the stack is empty.

DSA Rust

fn check_empty(stack: &Vec<i32>) -> bool {
    if stack.[1]() {
        true
    } else {
        false
    }
}

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

Alen

Bpop

Cis_empty

Dcapacity

Attempts:

3 left

💡 Hint

Common Mistakes

Using len() returns a number, which cannot be used directly as a boolean condition.

Using pop() removes elements and is not for checking emptiness.

The is_empty() method returns a boolean directly, so the if-else can use it correctly.

4fill in blank

hard

Fill both blanks to create a function that returns true if the stack is full.

DSA Rust

fn check_full(stack: &Vec<i32>, max_size: usize) -> bool {
    stack.[1]() == [2]
}

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

Alen

Bcapacity

Cmax_size

Dis_empty

Attempts:

3 left

💡 Hint

Common Mistakes

Using capacity() instead of max_size parameter.

Using is_empty() which checks for emptiness, not fullness.

The function compares the current length of the stack with the maximum allowed size.

5fill in blank

hard

Fill all three blanks to create a function that returns a message about stack status.

DSA Rust

fn stack_status(stack: &Vec<i32>, capacity: usize) -> String {
    if stack.[1]() {
        String::from("Stack is empty")
    } else if stack.[3]() == [2] {
        String::from("Stack is full")
    } else {
        String::from("Stack has space")
    }
}

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

Ais_empty

Bcapacity

Clen

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop() which removes elements instead of checking.

Mixing up len() and capacity() in conditions.

The function checks if the stack is empty using is_empty(), then if its length equals capacity, otherwise it has space.

Practice

1. What does the is_empty() method of a stack typically check?

easy

A. If the stack has more than one element

B. If the stack is full and cannot accept more elements

C. If the stack has exactly one element

D. If the stack has no elements inside

Solution

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

   This method checks whether the stack contains any elements or not.

2. Step 2: Interpret the meaning of empty stack

   An empty stack means it has zero elements inside, so is_empty() returns true only in this case.

3. Final Answer:

   If the stack has no elements inside -> Option D

4. Quick Check:

   Empty stack means no elements [OK]

Hint: Empty means zero elements inside the stack [OK]

Common Mistakes:

• Confusing empty with full
• Thinking empty means one element
• Assuming empty means stack is null

2. Which of the following is the correct Rust syntax to check if a stack named stack is full assuming it has a fixed capacity stored in capacity and current size in size?

easy

A. if stack.len() == capacity { /* full */ }

B. if stack.size == capacity { /* full */ }

C. if stack.is_full() { /* full */ }

D. if stack.size > capacity { /* full */ }

Solution

1. Step 1: Identify how to get current stack size

   In Rust, len() method is commonly used to get the current number of elements in a collection like a stack.

2. Step 2: Compare current size with capacity

   If stack.len() equals capacity, the stack is full.

3. Final Answer:

   if stack.len() == capacity { /* full */ } -> Option A

4. Quick Check:

   Use len() to check size [OK]

Hint: Use stack.len() to get current size in Rust [OK]

Common Mistakes:

• Using stack.size instead of stack.len()
• Checking size > capacity instead of == capacity
• Assuming is_full() method exists by default

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

struct Stack {
    elements: Vec<i32>,
    capacity: usize,
}

impl Stack {
    fn is_full(&self) -> bool {
        self.elements.len() == self.capacity
    }

    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }
}

fn main() {
    let stack = Stack { elements: vec![1, 2, 3], capacity: 3 };
    println!("{} {}", stack.is_empty(), stack.is_full());
}

medium

A. false true

B. true false

C. false false

D. true true

Solution

1. Step 1: Check if stack is empty

   The stack has elements [1, 2, 3], so is_empty() returns false.

2. Step 2: Check if stack is full

   The stack capacity is 3 and current length is 3, so is_full() returns true.

3. Final Answer:

   false true -> Option A

4. Quick Check:

   Elements present = not empty, length == capacity = full [OK]

Hint: Empty false if elements exist; full true if length equals capacity [OK]

Common Mistakes:

• Thinking stack is empty when it has elements
• Confusing is_empty() and is_full() return values
• Ignoring capacity when checking full

4. Identify the error in the following Rust code that checks if a stack is empty:

struct Stack {
    elements: Vec<i32>,
}

impl Stack {
    fn is_empty(&self) -> bool {
        self.elements.len() = 0
    }
}

medium

A. Vec<i32> cannot be used to store stack elements

B. Missing return type in is_empty method

C. Using '=' instead of '==' for comparison in is_empty method

D. is_empty method should take mutable self parameter

Solution

1. Step 1: Check the comparison operator in is_empty

   The code uses single '=' which is assignment, not comparison. It should use '==' to compare length with zero.

2. Step 2: Confirm other parts are correct

   The return type bool is present, Vec<i32> is valid, and self does not need to be mutable for this check.

3. Final Answer:

   Using '=' instead of '==' for comparison in is_empty method -> Option C

4. Quick Check:

   Use '==' for comparison, not '=' [OK]

Hint: Use '==' to compare values, '=' is assignment [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Forgetting return type bool
• Making self mutable unnecessarily

5. You have a stack with capacity 5 and current elements [10, 20, 30]. You want to write a Rust function can_push that returns true if the stack is not full and false otherwise. Which implementation is correct?

struct Stack {
    elements: Vec<i32>,
    capacity: usize,
}

impl Stack {
    fn can_push(&self) -> bool {
        // Choose correct condition
    }
}

hard

A. self.elements.len() <= self.capacity

B. self.elements.len() < self.capacity

C. self.elements.len() == self.capacity

D. self.elements.len() > self.capacity

Solution

1. Step 1: Understand when pushing is allowed

   You can push only if the stack is not full, meaning current size is less than capacity.

2. Step 2: Choose the correct comparison

   If length is less than capacity, pushing is possible. If equal or more, stack is full or invalid.

3. Final Answer:

   self.elements.len() < self.capacity -> Option B

4. Quick Check:

   Push allowed if size < capacity [OK]

Hint: Push allowed only if current size less than capacity [OK]

Common Mistakes:

• Using <= instead of < allows overflow
• Checking == means no room left
• Using > is logically incorrect