Array Deletion at Beginning in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting first element from a Rust vector

What is the output of this Rust code after deleting the first element from the vector?

DSA Rust

fn main() {
    let mut v = vec![10, 20, 30, 40];
    v.remove(0);
    println!("{:?}", v);
}

A [20, 30, 40]

B [10, 20, 30, 40]

C [30, 40]

D panic at index out of bounds

💡 Hint

Removing element at index 0 shifts all elements left.

The remove(0) call deletes the first element (10). The vector then contains [20, 30, 40].

❓ Predict Output

intermediate

Result of shifting elements after deletion

What will be printed after deleting the first element from this Rust vector?

DSA Rust

fn main() {
    let mut v = vec![5, 15, 25, 35, 45];
    v.remove(0);
    println!("{:?}", v);
}

A [25, 35, 45]

B [5, 15, 25, 35, 45]

C Index out of bounds panic

D [15, 25, 35, 45]

💡 Hint

Removing index 0 shifts all elements left by one.

The first element 5 is removed, so the vector becomes [15, 25, 35, 45].

🔧 Debug

advanced

Why does this Rust code panic when deleting the first element?

This Rust code panics when trying to remove the first element. What is the cause?

DSA Rust

fn main() {
    let mut v: Vec<i32> = Vec::new();
    v.remove(0);
}

A The vector must be mutable to remove elements.

B The remove method is not allowed on vectors.

C The vector is empty, so remove(0) causes an index out of bounds panic.

D Rust vectors cannot remove elements at index 0.

💡 Hint

Check if the vector has any elements before removing.

Calling remove(0) on an empty vector causes a panic because index 0 does not exist.

❓ Predict Output

advanced

Output after multiple deletions at beginning

What is the output after removing the first element twice from this Rust vector?

DSA Rust

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    v.remove(0);
    v.remove(0);
    println!("{:?}", v);
}

A panic at index out of bounds

B [3, 4, 5]

C [1, 3, 4, 5]

D [2, 3, 4, 5]

💡 Hint

Each remove(0) deletes the current first element and shifts left.

First remove deletes 1, vector becomes [2,3,4,5]. Second remove deletes 2, vector becomes [3,4,5].

🧠 Conceptual

expert

Time complexity of deleting the first element in a Rust vector

What is the time complexity of deleting the first element from a Rust vector using remove(0)?

A O(n), because all elements after the first must be shifted left.

B O(1), because vectors support fast removal at the beginning.

C O(n^2), because each removal copies the entire vector.

D O(log n), due to internal binary search optimizations.

💡 Hint

Consider what happens to elements after the removed index.

Removing the first element requires shifting all subsequent elements left by one, which takes linear time O(n).

Practice

1. What happens when you delete the first element from an array in Rust using remove(0)?

easy

A. The array elements remain unchanged.

B. The last element is removed instead of the first.

C. The array becomes empty regardless of its original size.

D. The first element is removed and all other elements shift left by one position.

Solution

1. Step 1: Understand remove(0) method

   The remove(0) method removes the element at index 0, which is the first element in the array.

2. Step 2: Effect on array elements

   After removal, all elements to the right shift left by one to fill the gap, reducing the array length by one.

3. Final Answer:

   The first element is removed and all other elements shift left by one position. -> Option D

4. Quick Check:

   Deleting at start shifts elements left [OK]

Hint: Deleting at index 0 shifts all elements left by one [OK]

Common Mistakes:

• Thinking last element is removed instead of first
• Assuming array size stays the same
• Believing elements do not shift after deletion

2. Which of the following Rust code snippets correctly deletes the first element from a vector v?

easy

A. v.remove(0);

B. v.delete(0);

C. v.pop_front();

D. v.shift();

Solution

1. Step 1: Identify correct Rust method for deletion at index

   Rust vectors use remove(index) to delete element at a specific position.

2. Step 2: Check other options for validity

   delete, pop_front, and shift are not valid Rust vector methods.

3. Final Answer:

   v.remove(0); -> Option A

4. Quick Check:

   Use remove(0) to delete first element [OK]

Hint: Use remove(0) to delete first element in Rust vector [OK]

Common Mistakes:

• Using non-existent methods like pop_front or shift
• Confusing Rust with other languages' syntax
• Trying to use delete which is invalid in Rust

3. What is the output of the following Rust code?

let mut v = vec![10, 20, 30, 40];
v.remove(0);
println!("{:?}", v);

medium

A. [20, 30, 40]

B. [10, 20, 30, 40]

C. [30, 40]

D. [40]

Solution

1. Step 1: Initial vector elements

   The vector v starts as [10, 20, 30, 40].

2. Step 2: Remove first element

   v.remove(0) removes 10, shifting remaining elements left.

3. Step 3: Resulting vector

   After removal, v becomes [20, 30, 40].

4. Final Answer:

   [20, 30, 40] -> Option A

5. Quick Check:

   Remove first element shifts left [OK]

Hint: Removing index 0 drops first element, shifts others left [OK]

Common Mistakes:

• Expecting original vector unchanged
• Thinking multiple elements removed
• Confusing output format

4. Identify the error in this Rust code that tries to delete the first element of a vector:

let mut v = vec![1, 2, 3];
v.remove();

medium

A. Cannot remove elements from a vector.

B. Missing index argument in remove method.

C. remove method does not exist for vectors.

D. Vector cannot be mutable.

Solution

1. Step 1: Check method signature

   The remove method requires an index argument specifying which element to remove.

2. Step 2: Identify missing argument

   The code calls v.remove() without any index, causing a compile error.

3. Final Answer:

   Missing index argument in remove method. -> Option B

4. Quick Check:

   remove needs index argument [OK]

Hint: Always provide index to remove method [OK]

Common Mistakes:

• Calling remove without index
• Thinking remove works like pop() without arguments
• Assuming vector immutability causes error

5. Given a vector v = vec![5, 10, 15, 20, 25], write Rust code to delete the first two elements and print the resulting vector. What will be the output?

hard

A. [5, 10, 15]

B. [10, 15, 20, 25]

C. [15, 20, 25]

D. [20, 25]

Solution

1. Step 1: Remove first element twice

   Calling v.remove(0) twice removes elements at index 0 each time, first 5 then 10.

2. Step 2: Resulting vector after removals

   After removals, vector becomes [15, 20, 25].

3. Final Answer:

   [15, 20, 25] -> Option C

4. Quick Check:

   Two removals at index 0 drop first two elements [OK]

Hint: Remove index 0 repeatedly to delete from start [OK]

Common Mistakes:

• Removing only once instead of twice
• Removing wrong indices after first removal
• Expecting original vector unchanged