Push Operation on Stack in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to push an element onto the stack.

DSA Rust

stack.push([1]);

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

Apop()

Bvalue

Clen()

Dclear()

Attempts:

3 left

💡 Hint

Common Mistakes

Using stack.pop() instead of pushing a value.

Trying to push the length of the stack.

Calling clear() which empties the stack.

The push method adds the given value to the top of the stack.

2fill in blank

medium

Complete the code to create a new empty stack using a vector.

DSA Rust

let mut stack: Vec<i32> = [1]::new();

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

AArray

BStack

CList

DVec

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-existent Stack type.

Using List which is not a Rust standard type.

Using Array which has fixed size.

In Rust, a stack can be implemented using a Vec. The Vec::new() creates an empty vector.

3fill in blank

hard

Fix the error in the push operation to add 10 to the stack.

DSA Rust

stack.[1](10);

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

Apush

Bpop

Cinsert

Dremove

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop which removes the top element.

Using remove which removes an element by index.

Using insert which inserts at a specific position.

The correct method to add an element to the top of the stack is push.

4fill in blank

hard

Fill both blanks to push the variable item onto the stack and print the stack length.

DSA Rust

stack.[1](item);
println!("Stack size: {}", stack.[2]());

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

Apush

Blen

Cpop

Dclear

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push.

Using clear which empties the stack.

Using pop to get length instead of len.

Use push to add item to the stack, and len() to get the current size.

5fill in blank

hard

Fill all three blanks to push the uppercase version of word onto the stack if its length is greater than 3.

DSA Rust

if word.[1]() > 3 {
    stack.[2](word.[3]());
}

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

Alen

Bpush

Cto_uppercase

Dpop

Attempts:

3 left

💡 Hint

Common Mistakes

Using pop instead of push.

Using to_lowercase instead of to_uppercase.

Checking length incorrectly.

Check length with len(), push with push, and convert to uppercase with to_uppercase().

Practice

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

easy

A. Removes the top element from the stack

B. Adds an element to the top of the stack

C. Returns the bottom element of the stack

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, where elements are added or removed from the top.

2. Step 2: Define push operation

   The push operation adds a new element on top of the existing elements in the stack.

3. Final Answer:

   Adds an element to the top of the stack -> Option B

4. Quick Check:

   Push = Add top element [OK]

Hint: Push always adds to the top of the stack [OK]

Common Mistakes:

• Confusing push with pop operation
• Thinking push removes elements
• Assuming push adds to the bottom

2. Which of the following is the correct Rust syntax to push an element 5 onto a stack implemented as a Vec<i32> named stack?

easy

A. stack.push(5);

B. stack.add(5);

C. stack.insert(5);

D. stack.append(5);

Solution

1. Step 1: Recall Rust Vec push method

   In Rust, Vec has a method push to add elements at the end (top of stack).

2. Step 2: Check method names

   add, insert, and append have different meanings or require different parameters.

3. Final Answer:

   stack.push(5); -> Option A

4. Quick Check:

   Vec push method = stack.push(5); [OK]

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

Common Mistakes:

• Using .add() which does not exist for Vec
• Confusing .insert() which needs index
• Using .append() which merges vectors

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

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

medium

A. [10, 20, 30]

B. [30, 20, 10]

C. [10, 20]

D. Compilation error

Solution

1. Step 1: Trace push operations

   Elements 10, 20, and 30 are pushed in order, so stack contains [10, 20, 30].

2. Step 2: Understand Vec print format

   Printing with {:?} shows elements in insertion order, so output is [10, 20, 30].

3. Final Answer:

   [10, 20, 30] -> Option A

4. Quick Check:

   Push order preserved in Vec print [OK]

Hint: Vec prints elements in insertion order [OK]

Common Mistakes:

• Assuming stack prints top element first
• Confusing push order with pop order
• Expecting reversed output

4. Identify the error in this Rust code that tries to push an element onto a stack:

let stack = Vec::new();
stack.push(100);

medium

A. Missing semicolon after push

B. Vec::new() is incorrect syntax

C. push method does not exist for Vec

D. stack is immutable, cannot push

Solution

1. Step 1: Check variable mutability

   The variable stack is declared immutable by default, so push cannot modify it.

2. Step 2: Understand push method requirements

   push requires the vector to be mutable to add elements.

3. Final Answer:

   stack is immutable, cannot push -> Option D

4. Quick Check:

   Mutable vector needed for push [OK]

Hint: Declare stack as mutable with 'mut' to push [OK]

Common Mistakes:

• Forgetting to add 'mut' keyword
• Thinking Vec::new() is wrong syntax
• Assuming push is not a Vec method

5. You want to implement a stack using a Rust Vec<i32> and push elements 1, 2, 3 in that order. After pushing, you want to print the stack from top to bottom. Which code snippet correctly achieves this?

hard

A. let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
for i in stack.iter() {
println!("{}", i);
}

B. let mut stack = Vec::new();
stack.push(3);
stack.push(2);
stack.push(1);
for i in stack.iter() {
println!("{}", i);
}

C. let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
for i in stack.iter().rev() {
println!("{}", i);
}

D. let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
for i in stack.into_iter() {
println!("{}", i);
}

Solution

1. Step 1: Push elements in order

   Elements 1, 2, 3 are pushed in order, so stack is [1, 2, 3] with 3 at top.

2. Step 2: Print from top to bottom

   To print from top (last pushed) to bottom, iterate in reverse order using iter().rev().

3. Final Answer:

   Code snippet with stack.iter().rev() -> Option C

4. Quick Check:

   Reverse iteration prints top to bottom [OK]

Hint: Use .iter().rev() to print stack top to bottom [OK]

Common Mistakes:

• Printing in normal order shows bottom to top
• Pushing elements in reverse order
• Using into_iter() which consumes the stack