Array Rotation Techniques in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2 Positions

What is the output of the following Rust code that rotates an array to the left by 2 positions?

DSA Rust

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

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

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

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

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

💡 Hint

Think about moving the first two elements to the end of the array.

The rotate_left(2) method moves the first two elements to the end, shifting the rest to the front.

❓ Predict Output

intermediate

Output of Right Rotation by 3 Positions

What is the output of this Rust code that rotates an array to the right by 3 positions?

DSA Rust

fn main() {
    let mut arr = [10, 20, 30, 40, 50, 60];
    arr.rotate_right(3);
    println!("{:?}", arr);
}

A [30, 40, 50, 60, 10, 20]

B [60, 10, 20, 30, 40, 50]

C [50, 60, 10, 20, 30, 40]

D [40, 50, 60, 10, 20, 30]

💡 Hint

Right rotation by 3 moves last three elements to the front.

rotate_right(3) moves the last three elements to the front, shifting others right.

🧠 Conceptual

advanced

Understanding Time Complexity of Array Rotation

What is the time complexity of rotating an array of size n by k positions using Rust's built-in rotate_left or rotate_right methods?

A O(k)

B O(n)

C O(1)

D O(n*k)

💡 Hint

Consider how many elements need to be moved or swapped.

Rust's rotate methods perform rotation in linear time proportional to array size n.

🔧 Debug

advanced

Identify the Error in Manual Array Rotation Code

What error will this Rust code produce when trying to rotate an array left by 1 position manually?

DSA Rust

fn main() {
    let mut arr = [1, 2, 3, 4];
    let first = arr[0];
    for i in 0..arr.len() - 1 {
        arr[i] = arr[i + 1];
    }
    arr[arr.len() - 1] = first;
    println!("{:?}", arr);
}

A Index out of bounds panic

B Type mismatch error

C No error, prints rotated array

D Compilation error due to immutable borrow

💡 Hint

Check the loop range and array indexing carefully.

The loop accesses arr[i + 1] when i reaches last index, causing out of bounds panic.

🚀 Application

expert

Result of Multiple Rotations on an Array

Given the Rust code below, what is the final state of the array after all rotations?

DSA Rust

fn main() {
    let mut arr = [7, 14, 21, 28, 35];
    arr.rotate_left(1);
    arr.rotate_right(2);
    arr.rotate_left(3);
    println!("{:?}", arr);
}

A [21, 28, 35, 7, 14]

B [35, 7, 14, 21, 28]

C [14, 21, 28, 35, 7]

D [28, 35, 7, 14, 21]

💡 Hint

Apply each rotation step by step on paper.

After first rotate_left(1): [14, 21, 28, 35, 7] Then rotate_right(2): [35, 7, 14, 21, 28] Finally rotate_left(3): [21, 28, 35, 7, 14]

Practice

1. What does rotating an array to the left by 2 positions mean for the array [1, 2, 3, 4, 5]?

easy

A. The last two elements move to the front, resulting in [4, 5, 1, 2, 3]

B. The first two elements move to the end, resulting in [3, 4, 5, 1, 2]

C. The array is reversed, resulting in [5, 4, 3, 2, 1]

D. The array remains unchanged

Solution

1. Step 1: Understand left rotation by 2

   Left rotation by 2 means removing the first two elements and placing them at the end.

2. Step 2: Apply rotation on given array

   Starting with [1, 2, 3, 4, 5], removing first two elements [1, 2] and appending them at the end gives [3, 4, 5, 1, 2].

3. Final Answer:

   [3, 4, 5, 1, 2] -> Option B

4. Quick Check:

   Left rotate by 2 = first 2 elements moved to end [OK]

Hint: Left rotate by k moves first k elements to the end [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Not moving elements but just swapping
• Thinking rotation reverses the array

2. Which of the following Rust code snippets correctly rotates an array arr of length 5 to the right by 1 position?

easy

A. let rotated = [&arr[0..4], &arr[4..5]].concat();

B. let rotated = [&arr[1..5], &arr[0..1]].concat();

C. let rotated = [&arr[4..5], &arr[0..4]].concat();

D. let rotated = [&arr[3..5], &arr[0..3]].concat();

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 means last element moves to front, rest shift right.

2. Step 2: Check code slices for correct order

   let rotated = [&arr[4..5], &arr[0..4]].concat(); takes last element arr[4..5] and then first 4 elements arr[0..4], concatenating them correctly.

3. Final Answer:

   let rotated = [&arr[4..5], &arr[0..4]].concat(); -> Option C

4. Quick Check:

   Right rotate by 1 = last element + rest [OK]

Hint: Right rotate by 1 = last element + rest [OK]

Common Mistakes:

• Using wrong slice indices
• Concatenating slices in wrong order
• Confusing left and right rotation slices

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

let arr = vec![10, 20, 30, 40, 50];
let k = 2;
let n = arr.len();
let rotated: Vec<_> = arr.iter().cycle().skip(n - k).take(n).cloned().collect();
println!("{:?}", rotated);

medium

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

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

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

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

Solution

1. Step 1: Understand rotation logic in code

   Code cycles array, skips n-k=3 elements, then takes n=5 elements, effectively right rotating by 2.

2. Step 2: Trace elements after skipping 3

   Skipping first 3 elements: 10,20,30 skipped; next elements are 40,50, then cycle back 10,20,30.

3. Step 3: Collect 5 elements

   Elements collected: 40, 50, 10, 20, 30.

4. Final Answer:

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

5. Quick Check:

   Right rotate by 2 = last 2 elements front [OK]

Hint: Cycle and skip n-k for right rotation [OK]

Common Mistakes:

• Confusing skip count with k
• Mixing left and right rotation logic
• Not using cycle iterator correctly

4. The following Rust function is intended to left rotate an array by k positions. What is the bug?

fn left_rotate(arr: &mut [i32], k: usize) {
    let n = arr.len();
    for i in 0..k {
        let temp = arr[i];
        arr[i] = arr[n - k + i];
        arr[n - k + i] = temp;
    }
}

medium

A. It swaps wrong elements; rotation logic is incorrect

B. It causes index out of bounds error

C. It reverses the array instead of rotating

D. It does nothing because loop range is zero

Solution

1. Step 1: Analyze the swapping logic

   The code swaps arr[i] with arr[n-k+i], which does not achieve left rotation but swaps wrong pairs.

2. Step 2: Understand correct rotation method

   Left rotation requires shifting elements left and moving first k elements to end, not swapping like this.

3. Final Answer:

   It swaps wrong elements; rotation logic is incorrect -> Option A

4. Quick Check:

   Incorrect swap logic = wrong rotation [OK]

Hint: Rotation needs shift + append, not simple swaps [OK]

Common Mistakes:

• Swapping instead of shifting elements
• Using wrong indices for swapping
• Assuming swap equals rotation

5. Given an array arr = [1, 2, 3, 4, 5, 6], how can you rotate it left by 4 positions using Rust slice operations without extra space?

hard

A. Reverse first 4 elements, reverse last 2 elements, reverse entire array

B. Reverse last 4 elements, reverse first 2 elements, reverse entire array

C. Reverse entire array, reverse last 2 elements, reverse first 4 elements

D. Reverse first 2 elements, reverse last 4 elements, reverse entire array

Solution

1. Step 1: Understand rotation by reversal method

   Left rotate by k means reverse first k elements, reverse remaining, then reverse whole array.

2. Step 2: Apply to k=4, n=6

   Reverse first 4 elements [1,2,3,4], reverse last 2 elements [5,6], then reverse entire array.

3. Final Answer:

   Reverse first 4 elements, reverse last 2 elements, reverse entire array -> Option A

4. Quick Check:

   Rotation by reversal = reverse k, reverse n-k, reverse all [OK]

Hint: Rotate left k = reverse first k, reverse rest, reverse all [OK]

Common Mistakes:

• Reversing in wrong order
• Mixing k and n-k segments
• Using extra space instead of in-place reversal