Array Rotation Techniques in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2

What is the output of the following C++ code after rotating the array to the left by 2 positions?

DSA C++

int arr[] = {10, 20, 30, 40, 50};
int n = 5, d = 2;
int rotated[5];
for(int i = 0; i < n; i++) {
    rotated[i] = arr[(i + d) % n];
}
for(int i = 0; i < n; i++) {
    std::cout << rotated[i] << " ";
}

A 30 40 50 10 20

B 40 50 10 20 30

C 20 30 40 50 10

D 50 10 20 30 40

💡 Hint

Remember that left rotation by d means elements shift to the left by d positions, wrapping around.

The code shifts each element to the left by 2 positions. So element at index 0 moves to index (0+2)%5=2, which is 30, and so on.

❓ Predict Output

intermediate

Output of Right Rotation by 3

What is the output of the following C++ code after rotating the array to the right by 3 positions?

DSA C++

int arr[] = {1, 2, 3, 4, 5, 6};
int n = 6, d = 3;
int rotated[6];
for(int i = 0; i < n; i++) {
    rotated[(i + d) % n] = arr[i];
}
for(int i = 0; i < n; i++) {
    std::cout << rotated[i] << " ";
}

A 5 6 1 2 3 4

B 3 4 5 6 1 2

C 6 1 2 3 4 5

D 4 5 6 1 2 3

💡 Hint

Right rotation by d means elements move to the right by d positions, wrapping around.

Each element is placed at index (i + d) % n. So element 1 at index 0 moves to index 3, element 4 at index 3 moves to index 0, etc.

🔧 Debug

advanced

Identify the Error in Rotation Code

What error will the following C++ code produce when trying to rotate an array left by d positions?

DSA C++

int arr[] = {7, 8, 9, 10};
int n = 4, d = 5;
int rotated[4];
for(int i = 0; i < n; i++) {
    rotated[i] = arr[(i - d + n) % n];
}
for(int i = 0; i < n; i++) {
    std::cout << rotated[i] << " ";
}

A Runtime error due to negative index access

B Runs correctly and outputs: 8 9 10 7

C Compilation error due to modulo operator misuse

D Outputs: 7 8 9 10

💡 Hint

Check how modulo operator behaves with negative numbers in C++.

In C++, modulo with negative numbers can produce negative results, causing invalid negative array indices and runtime errors. Adding n before modulo fixes this.

🧠 Conceptual

advanced

Minimum Rotations to Restore Original Array

Given an array of length 7, if you rotate it left by 3 positions twice in a row, how many total left rotations are needed to restore the array to its original order?

A 21 rotations

B 14 rotations

C 7 rotations

D 3 rotations

💡 Hint

Think about how rotations add up modulo the array length.

Rotating left by 3 twice equals rotating left by 6. To restore original, rotate left by 1 more (total 7) because 7 % 7 = 0.

🚀 Application

expert

Output After Multiple Rotations

What is the output of the following C++ code after performing the described rotations?

DSA C++

int arr[] = {2, 4, 6, 8, 10};
int n = 5;
int temp;
// Rotate left by 1
for(int i = 0; i < n - 1; i++) {
    std::swap(arr[i], arr[i+1]);
}
// Rotate right by 2
for(int i = 0; i < 2; i++) {
    temp = arr[n-1];
    for(int j = n-1; j > 0; j--) {
        arr[j] = arr[j-1];
    }
    arr[0] = temp;
}
for(int i = 0; i < n; i++) {
    std::cout << arr[i] << " ";
}

A 10 2 4 6 8

B 6 8 10 2 4

C 4 6 8 10 2

D 8 10 2 4 6

💡 Hint

Perform each rotation step carefully and track the array state.

Left rotation by 1 using swaps results in {4,6,8,10,2}. Then right rotation by 2 results in {10,2,4,6,8}.

Practice

1. What does rotating an array to the left by 1 position do to the elements?

easy

A. Moves the last element to the front and shifts all others one position right

B. Moves the first element to the end and shifts all others one position left

C. Reverses the entire array

D. Sorts the array in ascending order

Solution

1. Step 1: Understand left rotation by 1

   Left rotation by 1 means the element at index 0 moves to the end.

2. Step 2: Effect on other elements

   All other elements shift one position to the left to fill the gap.

3. Final Answer:

   Moves the first element to the end and shifts all others one position left -> Option B

4. Quick Check:

   Left rotate by 1 = first element moves to end [OK]

Hint: Left rotate by 1 moves front element to back [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Thinking rotation reverses the array
• Assuming rotation sorts the array

2. Which of the following is the correct syntax to rotate an array arr of size n to the right by 1 position in C++?

easy

A. std::rotate(arr, arr + n, arr + 1);

B. std::rotate(arr, arr + 1, arr + n);

C. std::rotate(arr, arr + n - 1, arr + n);

D. std::rotate(arr + 1, arr, arr + n);

Solution

1. Step 1: Understand std::rotate parameters

   std::rotate takes three pointers: first, middle, last. It rotates the range [first, last) so that the element at middle becomes first.

2. Step 2: Rotate right by 1 means last element moves to front

   To rotate right by 1, middle should point to the last element (arr + n - 1).

3. Final Answer:

   std::rotate(arr, arr + n - 1, arr + n); -> Option C

4. Quick Check:

   Right rotate by 1 uses middle = last-1 [OK]

Hint: Right rotate by 1 uses middle = last-1 in std::rotate [OK]

Common Mistakes:

• Using middle = first + 1 for right rotation
• Swapping parameters order incorrectly
• Confusing rotate range boundaries

3. What is the output of the following C++ code?

int arr[] = {10, 20, 30, 40, 50};
int n = 5;
int d = 2;
std::rotate(arr, arr + d, arr + n);
for(int i = 0; i < n; i++) std::cout << arr[i] << " ";

medium

A. 30 40 50 10 20

B. 40 50 10 20 30

C. 50 10 20 30 40

D. 20 30 40 50 10

Solution

1. Step 1: Understand std::rotate with d=2

   std::rotate(arr, arr + 2, arr + 5) moves elements starting from index 2 to front.

2. Step 2: Rearrange array after rotation

   Elements from index 2 to 4: 30, 40, 50 come first, then elements from index 0 to 1: 10, 20.

3. Final Answer:

   30 40 50 10 20 -> Option A

4. Quick Check:

   Rotate left by 2 shifts first 2 elements to end [OK]

Hint: Rotate left by d moves first d elements to end [OK]

Common Mistakes:

• Confusing left and right rotation
• Off-by-one errors in index calculation
• Printing array before rotation

4. The following code is intended to rotate an array arr of size n to the left by d positions. What is the error?

void rotateLeft(int arr[], int n, int d) {
    for(int i = 0; i < d; i++) {
        int temp = arr[0];
        for(int j = 0; j < n - 1; j++) {
            arr[j] = arr[j+1];
        }
        arr[n - 1] = temp;
    }
}

medium

A. temp should be assigned arr[n-1] instead of arr[0]

B. Inner loop should run from j=1 to n-1

C. The outer loop should run from i=1 to d

D. Accessing arr[n] causes out-of-bounds error

Solution

1. Step 1: Analyze inner loop index usage

   The inner loop runs j from 0 to n-1, but accesses arr[j+1]. When j = n-1, arr[j+1] = arr[n] is accessed.

2. Step 2: Identify out-of-bounds access

   Array indices go from 0 to n-1, so arr[n] is invalid and causes out-of-bounds error.

3. Final Answer:

   Accessing arr[n] causes out-of-bounds error -> Option D

4. Quick Check:

   Array index out of bounds at arr[n] [OK]

Hint: Array indices go 0 to n-1, arr[n] is invalid [OK]

Common Mistakes:

• Ignoring out-of-bounds access
• Misunderstanding loop ranges
• Incorrectly assigning temp value

5. Given an array arr = {1, 2, 3, 4, 5, 6, 7} and d = 3, which sequence of operations correctly rotates the array to the left by d positions using the reversal algorithm?

hard

A. Reverse first d elements, reverse last n-d elements, then reverse whole array

B. Reverse whole array, reverse first d elements, then reverse last n-d elements

C. Reverse first d elements, reverse whole array, then reverse last n-d elements

D. Reverse whole array, reverse last n-d elements, then reverse first d elements

Solution

1. Step 1: Understand reversal algorithm steps

   To rotate left by d, first reverse the first d elements.

2. Step 2: Reverse last n-d elements, then reverse whole array

   Next reverse the last n-d elements, finally reverse the entire array to get the rotated result.

3. Final Answer:

   Reverse first d elements, reverse last n-d elements, then reverse whole array -> Option A

4. Quick Check:

   Reversal algorithm order = first d, last n-d, whole [OK]

Hint: Left rotate reversal: first d, last n-d, then whole [OK]

Common Mistakes:

• Reversing parts before whole array
• Mixing order of reversing segments
• Confusing left and right rotation steps