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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting an element in the middle of the array?

Consider the Rust code below that inserts the value 99 into the middle of a vector. What will be the printed vector after insertion?

DSA Rust

fn main() {
    let mut v = vec![10, 20, 30, 40];
    let mid = v.len() / 2;
    v.insert(mid, 99);
    println!("{:?}", v);
}

A [99, 10, 20, 30, 40]

B [10, 20, 30, 99, 40]

C [10, 20, 99, 30, 40]

D [10, 99, 20, 30, 40]

💡 Hint

Remember that insert shifts elements to the right starting at the given index.

The middle index is 2 (4/2). Inserting 99 at index 2 shifts elements at and after index 2 to the right.

❓ Predict Output

intermediate

What is the output after inserting at the middle of an odd-length array?

Given the Rust code below, what will be the vector printed after inserting 77 in the middle?

DSA Rust

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];
    let mid = v.len() / 2;
    v.insert(mid, 77);
    println!("{:?}", v);
}

A [1, 2, 77, 3, 4, 5]

B [77, 1, 2, 3, 4, 5]

C [1, 2, 3, 77, 4, 5]

D [1, 77, 2, 3, 4, 5]

💡 Hint

Integer division truncates. The middle index is floor of length/2.

Length is 5, so middle index is 2. Insert 77 at index 2 shifts elements from index 2 right.

🔧 Debug

advanced

What error does this Rust code produce when inserting at middle index?

Analyze the Rust code below. What error will it produce when run?

DSA Rust

fn main() {
    let mut v = vec![5, 10, 15];
    let mid = v.len() / 2;
    v.insert(mid + 5, 20);
    println!("{:?}", v);
}

A No error, output: [5, 10, 15, 20]

B SyntaxError

C TypeError

D panic: index out of bounds

💡 Hint

Check if the insert index is valid for the vector length.

The insert index is 1 + 5 = 6, which is beyond vector length 3, causing panic at runtime.

🧠 Conceptual

advanced

How does inserting at the middle index affect the array elements?

When inserting an element at the middle index of an array or vector, what happens to the elements at and after that index?

A The array size shrinks by one to accommodate the new element.

B They shift one position to the right to make space for the new element.

C They remain unchanged; the new element replaces the middle element.

D They shift one position to the left, overwriting the middle element.

💡 Hint

Think about how arrays maintain order when inserting.

Insertion shifts elements at and after the insertion index right by one to keep all elements.

🚀 Application

expert

After multiple middle insertions, what is the final vector?

Starting with an empty vector, the following insertions happen in order: 1. Insert 10 at middle 2. Insert 20 at middle 3. Insert 30 at middle What is the final vector printed?

DSA Rust

fn main() {
    let mut v = Vec::new();
    let mid1 = v.len() / 2;
    v.insert(mid1, 10);
    let mid2 = v.len() / 2;
    v.insert(mid2, 20);
    let mid3 = v.len() / 2;
    v.insert(mid3, 30);
    println!("{:?}", v);
}

A [20, 30, 10]

B [10, 20, 30]

C [30, 20, 10]

D [10, 30, 20]

💡 Hint

Calculate the middle index before each insertion carefully.

Insertions happen at indices 0, then 0, then 1 shifting elements accordingly, resulting in [20, 30, 10].

Practice

1. What does inserting an element at the middle index of an array mean?

easy

A. Adding a new element at the end of the array

B. Replacing the middle element with a new one

C. Adding a new element exactly in the center, shifting others right

D. Removing the middle element from the array

Solution

1. Step 1: Understand middle index insertion

   Inserting at the middle means placing a new element at the center position, pushing existing elements to the right.

2. Step 2: Differentiate from other operations

   Replacing or removing elements changes existing data, but insertion adds a new element without deletion.

3. Final Answer:

   Adding a new element exactly in the center, shifting others right -> Option C

4. Quick Check:

   Middle insertion means add and shift [OK]

Hint: Middle insertion adds element, shifts others right [OK]

Common Mistakes:

• Thinking insertion replaces an element
• Confusing insertion with removal
• Assuming insertion always happens at end

2. Which Rust code correctly inserts the value 99 at the middle index of a vector named vec?

easy

A. vec.insert(vec.len() / 2, 99);

B. vec.push(99);

C. vec[vec.len() / 2] = 99;

D. vec.remove(vec.len() / 2); vec.push(99);

Solution

1. Step 1: Identify correct insertion method

   Rust's insert method adds an element at a given index, shifting others right.

2. Step 2: Calculate middle index and apply insert

   Using vec.len() / 2 gives the middle index; vec.insert places 99 there correctly.

3. Final Answer:

   vec.insert(vec.len() / 2, 99); -> Option A

4. Quick Check:

   Use insert with middle index [OK]

Hint: Use vec.insert(middle_index, value) to insert [OK]

Common Mistakes:

• Using push adds at end, not middle
• Assigning with vec[index] replaces, not inserts
• Removing then pushing changes order

3. What is the output of this Rust code?

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

medium

A. [10, 20, 30, 25, 40]

B. [10, 20, 25, 30, 40]

C. [10, 25, 20, 30, 40]

D. [25, 10, 20, 30, 40]

Solution

1. Step 1: Calculate middle index

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

2. Step 2: Insert 25 at index 2

   Inserting 25 at index 2 shifts elements at and after index 2 right: 30 and 40 move right.

3. Final Answer:

   [10, 20, 25, 30, 40] -> Option B

4. Quick Check:

   Insert at middle shifts elements right [OK]

Hint: Middle index = length/2; insert shifts right [OK]

Common Mistakes:

• Inserting at wrong index
• Confusing insert with replace
• Miscounting vector length

4. Identify the error in this Rust code that tries to insert 50 at the middle of vec:

let mut vec = vec![1, 2, 3, 4, 5];
let mid = vec.len() / 2;
vec[mid] = 50;
println!("{:?}", vec);

medium

A. Using assignment replaces element instead of inserting

B. vec.len() / 2 is incorrect middle index

C. vec is immutable, cannot modify

D. println! syntax is wrong

Solution

1. Step 1: Understand vec[mid] = 50;

   This replaces the element at index mid instead of inserting a new one.

2. Step 2: Correct method is insert

   To insert, use vec.insert(mid, 50); which shifts elements right.

3. Final Answer:

   Using assignment replaces element instead of inserting -> Option A

4. Quick Check:

   Assignment replaces, insert adds [OK]

Hint: Use insert() to add, not assignment [OK]

Common Mistakes:

• Replacing element instead of inserting
• Misunderstanding vector mutability
• Incorrect println! usage

5. Given a vector vec = vec![5, 10, 15, 20, 25, 30], write Rust code to insert 17 exactly in the middle so that the vector remains sorted. What will be the vector after insertion?

hard

A. [5, 10, 15, 20, 25, 30, 12]

B. [5, 10, 15, 12, 20, 25, 30]

C. [12, 5, 10, 15, 20, 25, 30]

D. [5, 10, 15, 17, 20, 25, 30]

Solution

1. Step 1: Find middle index for insertion

   Vector length is 6, middle index is 6 / 2 = 3.

2. Step 2: Insert 17 at index 3 to keep sorted order

   Inserting 17 at index 3 shifts elements 20, 25, 30 right, keeping order.

3. Final Answer:

   [5, 10, 15, 17, 20, 25, 30] -> Option D

4. Quick Check:

   Insert 17 at middle index 3 to keep sorted [OK]

Hint: Insert at length/2 to keep sorted vector [OK]

Common Mistakes:

• Inserting at wrong index breaking order
• Appending instead of inserting
• Replacing element instead of inserting