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

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after inserting at the beginning?

Consider the Rust code below that inserts elements at the beginning of a vector. What will be printed?

DSA Rust

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

A [2, 3, 4]

B [1, 3, 4]

C [1, 2, 3, 4]

D [2, 3, 4, 1]

💡 Hint

Remember that insert at index 0 adds the element at the start, shifting others right.

The insert(0, 1) call places 1 at the start, pushing existing elements right. So the vector becomes [1, 2, 3, 4].

❓ Predict Output

intermediate

What is the vector after multiple insertions at the beginning?

Given the Rust code below, what is the final vector printed?

DSA Rust

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

A [1, 3, 4]

B [1, 2, 3, 4]

C [3, 4, 1, 2]

D [2, 1, 3, 4]

💡 Hint

Each insert at index 0 adds the element at the front, pushing others right.

First insert(0, 2) makes [2, 3, 4], then insert(0, 1) makes [1, 2, 3, 4].

🔧 Debug

advanced

Why does this Rust code panic when inserting at the beginning?

Look at the Rust code below. It panics at runtime. What is the cause?

DSA Rust

fn main() {
    let mut v = Vec::new();
    v.insert(1, 10);
    println!("{:?}", v);
}

A Index 1 is out of bounds because the vector is empty.

B The vector cannot hold the value 10 because of type mismatch.

C The insert method is not allowed on empty vectors.

D The println! macro is used incorrectly.

💡 Hint

Check the valid index range for insert in an empty vector.

Inserting at index 1 in an empty vector is invalid because valid indices are only 0 (start). This causes a panic.

🧠 Conceptual

advanced

What is the time complexity of inserting at the beginning of a Rust vector?

When inserting an element at the start (index 0) of a Rust vector, what is the time complexity and why?

A O(n^2), because each insertion requires copying the entire vector twice.

B O(1), because vectors allow fast insertion at the start.

C O(log n), because the vector uses binary search internally.

D O(n), because all existing elements must be shifted right by one position.

💡 Hint

Think about what happens to existing elements when inserting at the front.

Inserting at index 0 requires shifting all elements one position to the right, which takes linear time proportional to the vector size.

🚀 Application

expert

After these insertions, what is the vector's state?

Given the Rust code below, what is the final vector printed?

DSA Rust

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

A [2, 3, 4, 5, 6]

B [3, 2, 4, 5, 6]

C [2, 4, 3, 5, 6]

D [5, 6, 2, 3, 4]

💡 Hint

Track each insertion step carefully by index and vector state.

Start: [5,6] insert(0,3) -> [3,5,6] insert(1,4) -> [3,4,5,6] insert(0,2) -> [2,3,4,5,6]

Practice

1. What happens when you insert an element at the beginning of a vector in Rust using insert(0, value)?

easy

A. The element is added at the end of the vector.

B. The element is added at the start, and all other elements shift right by one position.

C. The element replaces the first element without shifting others.

D. The vector size remains the same and no element is added.

Solution

1. Step 1: Understand insert(0, value) behavior

   In Rust, calling insert(0, value) on a vector adds the value at index 0.

2. Step 2: Effect on existing elements

   All existing elements shift one position to the right to make space for the new element.

3. Final Answer:

   The element is added at the start, and all other elements shift right by one position. -> Option B

4. Quick Check:

   Insert at index 0 shifts elements right [OK]

Hint: Insert at index 0 shifts all elements right [OK]

Common Mistakes:

• Thinking insert replaces the first element
• Assuming insert adds at the end
• Believing array size stays the same

2. Which of the following Rust code snippets correctly inserts the value 10 at the beginning of a vector named vec?

easy

A. vec.insert(0, 10);

B. vec.push(10);

C. vec[0] = 10;

D. vec.add(0, 10);

Solution

1. Step 1: Identify correct method for insertion at index

   Rust vectors use insert(index, value) to add elements at a specific position.

2. Step 2: Check each option

   vec.insert(0, 10); uses insert(0, 10), which inserts 10 at the start. vec.push(10); adds at the end. vec[0] = 10; replaces the first element without insertion. vec.add(0, 10); is invalid syntax.

3. Final Answer:

   vec.insert(0, 10); -> Option A

4. Quick Check:

   Use insert(0, value) to add at start [OK]

Hint: Use insert(0, value) to add at beginning [OK]

Common Mistakes:

• Using push() adds at end, not beginning
• Assigning vec[0] replaces element, no insertion
• Using non-existent method add()

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

let mut vec = vec![2, 3, 4];
vec.insert(0, 1);
println!("{:?}", vec);

medium

A. [2, 3, 4, 1]

B. [2, 3, 4]

C. [1, 3, 4]

D. [1, 2, 3, 4]

Solution

1. Step 1: Initial vector state

   The vector starts as [2, 3, 4].

2. Step 2: Insert 1 at index 0

   Using vec.insert(0, 1) adds 1 at the start, shifting others right.

3. Final Answer:

   [1, 2, 3, 4] -> Option D

4. Quick Check:

   Insert at start shifts elements right [OK]

Hint: Insert at 0 adds element at front, shifts others right [OK]

Common Mistakes:

• Expecting element added at end
• Thinking insert replaces element
• Ignoring vector shift after insert

4. Identify the error in this Rust code:

let mut vec = vec![1, 2, 3];
vec.insert(5, 0);

medium

A. The index 5 is out of bounds for the vector of length 3.

B. The vector is immutable; it should be declared mutable.

C. The insert method parameters are reversed; index should be first, value second.

D. The insert method does not exist for vectors.

Solution

1. Step 1: Analyze the insert index

   The vector has length 3, valid insert indices are 0 to 3. Index 5 is out of bounds, causing runtime panic.

2. Step 2: Confirm syntax and mutability

   Parameters follow correct order insert(index, value); vector is declared mutable.

3. Final Answer:

   The index 5 is out of bounds for the vector of length 3. -> Option A

4. Quick Check:

   Insert index must be within vector bounds [OK]

Hint: Check insert(index, value) and index within vector length [OK]

Common Mistakes:

• Reversing insert parameters
• Using out-of-range index
• Forgetting to declare vector mutable

5. You have a vector vec = vec![10, 20, 30]. You want to insert multiple values [1, 2, 3] at the beginning efficiently. Which approach is best in Rust?

hard

A. Use a loop to insert each element at index 0 one by one.

B. Replace the original vector with the new elements only.

C. Create a new vector with the new elements, then extend it with the original vector.

D. Use vec.push() for each new element and then reverse the vector.

Solution

1. Step 1: Analyze inserting multiple elements at start

   Inserting one by one at index 0 shifts elements repeatedly, inefficient for multiple inserts.

2. Step 2: Efficient approach

   Create a new vector with new elements, then extend it with the original vector to combine efficiently.

3. Final Answer:

   Create a new vector with the new elements, then extend it with the original vector. -> Option C

4. Quick Check:

   Prepending by new vector + extend is efficient [OK]

Hint: Prepend multiple by new vector + extend original [OK]

Common Mistakes:

• Inserting elements one by one at index 0 (slow)
• Using push then reversing (extra steps)
• Replacing original vector loses data