Array Deletion at Middle Index in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting middle element from an array

What is the output of the following Rust code after deleting the middle element from the array?

DSA Rust

fn main() {
    let mut arr = vec![10, 20, 30, 40, 50];
    let mid = arr.len() / 2;
    arr.remove(mid);
    for val in &arr {
        print!("{} ", val);
    }
}

A 10 20 40 50

B 10 20 30 50

C 10 30 40 50

D 20 30 40 50

💡 Hint

Remember that the middle index is calculated as length divided by 2, and the remove method deletes the element at that index.

The array has 5 elements, so middle index is 2 (0-based). Removing element at index 2 removes 30. Remaining elements are 10, 20, 40, 50.

❓ Predict Output

intermediate

Resulting array after removing middle element from even-length array

What is the output of this Rust code after deleting the middle element from an even-length array?

DSA Rust

fn main() {
    let mut arr = vec![5, 15, 25, 35, 45, 55];
    let mid = arr.len() / 2;
    arr.remove(mid);
    for val in &arr {
        print!("{} ", val);
    }
}

A 5 15 35 45 55

B 5 15 25 35 55

C 5 15 25 45 55

D 5 25 35 45 55

💡 Hint

For even length, middle index is length/2, which is the higher middle element index.

Array length is 6, middle index is 3. Removing element at index 3 removes 35. Remaining elements are 5, 15, 25, 45, 55.

🔧 Debug

advanced

Identify the error in array deletion code

What error will this Rust code produce when trying to delete the middle element?

DSA Rust

fn main() {
    let mut arr = vec![1, 2, 3, 4];
    let mid = arr.len() / 2;
    arr.remove(mid + 1);
    println!("{:?}", arr);
}

A panic: index out of bounds

B SyntaxError

C No error, output: [1, 2, 3]

D TypeError

💡 Hint

Check the index used in remove method carefully.

Array length is 4, mid = 2, so mid + 1 = 3. Index 3 is valid (indices 0-3). Removes element 4 at index 3. No panic. Output: [1, 2, 3].

❓ Predict Output

advanced

Output after multiple middle deletions

What is the output after deleting the middle element twice from this array?

DSA Rust

fn main() {
    let mut arr = vec![2, 4, 6, 8, 10, 12, 14];
    for _ in 0..2 {
        let mid = arr.len() / 2;
        arr.remove(mid);
    }
    for val in &arr {
        print!("{} ", val);
    }
}

A 2 4 6 10 12 14

B 2 4 6 8 10 14

C 2 4 6 8 12 14

D 2 4 6 12 14

💡 Hint

Calculate middle index and remove element twice, updating array each time.

Initial array length 7, mid=3, remove element at index 3 (8). Array becomes [2,4,6,10,12,14]. Next length 6, mid=3, remove element at index 3 (10). Array becomes [2,4,6,12,14]. Output prints 2 4 6 12 14

🧠 Conceptual

expert

Effect of deleting middle element on array length and indexing

If you delete the middle element from an array of length n repeatedly until only one element remains, how many deletions will you perform and what will be the final element's index in the original array?

A Perform n/2 deletions; final element index is 0 (first element)

B Perform n-1 deletions; final element index is 0 (first element)

C Perform n-1 deletions; final element index is n/2 (middle index of original array)

D Perform n/2 deletions; final element index is n-1 (last element)

💡 Hint

Think about how many elements are removed and which element remains after repeatedly removing the middle.

Each deletion removes one element, so to reduce from n to 1 element requires n-1 deletions. Removing at floor(len/2) repeatedly always preserves the first element (original index 0).

Practice

1. What happens when you delete the middle element from an array with an odd number of elements?

easy

A. The array size remains the same but the middle element is set to zero.

B. The middle element is removed and the array size decreases by one.

C. The last element is removed instead of the middle element.

D. The array is reversed after deletion.

Solution

1. Step 1: Identify the middle index in an odd-length array

   The middle index is calculated as length divided by 2 (integer division).

2. Step 2: Remove the element at the middle index

   Deleting this element reduces the array size by one and shifts elements after it left.

3. Final Answer:

   The middle element is removed and the array size decreases by one. -> Option B

4. Quick Check:

   Deleting middle element shrinks array [OK]

Hint: Middle index = length / 2 for odd arrays [OK]

Common Mistakes:

• Thinking array size stays the same after deletion
• Removing last element instead of middle
• Not shifting elements after deletion

2. Which Rust code snippet correctly deletes the middle element from a vector v with odd length?

easy

A. v.pop(v.len() / 2);

B. v.delete(v.len() / 2);

C. v.remove(v.len() / 2);

D. v.erase(v.len() / 2);

Solution

1. Step 1: Identify Rust method to remove element by index

   Rust's Vec type uses remove(index) to delete element at given index.

2. Step 2: Calculate middle index and call remove

   Middle index is v.len() / 2. Calling v.remove(v.len() / 2) deletes middle element.

3. Final Answer:

   v.remove(v.len() / 2); -> Option C

4. Quick Check:

   Use remove(index) to delete element [OK]

Hint: Use Vec::remove(index) to delete element [OK]

Common Mistakes:

• Using non-existent methods like delete or erase
• Using pop which removes last element only
• Passing index to pop which takes no arguments

3. What is the output of this Rust code?

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

medium

A. [10, 30, 40, 50]

B. [10, 20, 30, 40]

C. [20, 30, 40, 50]

D. [10, 20, 40, 50]

Solution

1. Step 1: Calculate middle index of vector

   Vector length is 5, so middle index = 5 / 2 = 2.

2. Step 2: Remove element at index 2 and print vector

   Element at index 2 is 30, removed. Remaining vector is [10, 20, 40, 50].

3. Final Answer:

   [10, 20, 40, 50] -> Option D

4. Quick Check:

   Removed middle element 30, vector shrinks [OK]

Hint: Remove element at len()/2 index for middle deletion [OK]

Common Mistakes:

• Removing wrong index element
• Confusing index with value
• Expecting vector size unchanged

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

let mut v = vec![1, 2];
v.remove(v.len() / 2 + 1);
println!("{:?}", v);

medium

A. Index used for removal is off by one, causing panic.

B. Vector cannot be mutable for removal.

C. remove() method does not exist for vectors.

D. The println! macro is used incorrectly.

Solution

1. Step 1: Calculate middle index for even-length vector

   Vector length is 2, middle index should be 2 / 2 = 1.

2. Step 2: Check removal index used in code

   Code uses index 1 + 1 = 2, which is out of bounds.

3. Step 3: Understand consequences

   Index 2 >= length 2 causes runtime panic (out of bounds).

4. Final Answer:

   Index used for removal is off by one, causing panic. -> Option A

5. Quick Check:

   Use correct middle index = len()/2 [OK]

Hint: Middle index is len()/2, no +1 for removal [OK]

Common Mistakes:

• Adding +1 to middle index incorrectly
• Trying to remove from immutable vector
• Misusing remove method name

5. Given a vector v of even length, how can you delete the lower middle element (the one at index len()/2 - 1) and then print the updated vector in Rust?

hard

A. v.remove(v.len() / 2 - 1); println!("{:?}", v);

B. v.remove(v.len() / 2); println!("{:?}", v);

C. v.pop(); println!("{:?}", v);

D. v.remove(v.len() / 2 + 1); println!("{:?}", v);

Solution

1. Step 1: Identify lower middle index for even-length vector

   For even length, lower middle index is len()/2 - 1.

2. Step 2: Remove element at lower middle index and print vector

   Use v.remove(v.len() / 2 - 1) to delete lower middle element, then print with println!("{:?}", v);.

3. Final Answer:

   v.remove(v.len() / 2 - 1); println!("{:?}", v); -> Option A

4. Quick Check:

   Remove lower middle with len()/2 - 1 [OK]

Hint: For even length, lower middle = len()/2 - 1 [OK]

Common Mistakes:

• Removing upper middle instead of lower middle
• Using pop which removes last element
• Adding +1 to index incorrectly