Array Rotation Techniques in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is array rotation?

Array rotation means shifting the elements of an array to the left or right by a certain number of positions. Elements that move past the end come back around to the start.

intermediate

Explain the reversal algorithm for array rotation.

The reversal algorithm rotates an array by reversing parts of it. First, reverse the first part, then reverse the second part, and finally reverse the whole array. This achieves rotation without extra space.

beginner

What is the time complexity of rotating an array using the reversal algorithm?

The time complexity is O(n), where n is the number of elements in the array, because each element is reversed at most twice.

advanced

Describe the juggling algorithm for array rotation.

The juggling algorithm divides the array into sets based on the greatest common divisor (GCD) of the array size and rotation count. It then moves elements within these sets to rotate the array efficiently.

beginner

Why is it important to use modulo operation when rotating arrays?

Modulo helps handle rotation counts larger than the array size by wrapping the rotation count within the array length, preventing unnecessary full rotations.

What happens to elements that move past the end of the array during rotation?

A They stay at the end and duplicate

B They are removed from the array

C They wrap around to the start of the array

D They cause an error

In array rotation, elements that move past the end wrap around to the start, maintaining the array size.

Which algorithm rotates an array by reversing parts of it?

A Reversal algorithm

B Insertion sort

C Bubble sort

D Juggling algorithm

The reversal algorithm rotates an array by reversing segments and then the whole array.

What is the time complexity of the reversal algorithm for array rotation?

A O(n)

B O(log n)

C O(n^2)

D O(1)

The reversal algorithm runs in linear time O(n) because it reverses the array parts in place.

The juggling algorithm uses which mathematical concept to divide the array?

A Least common multiple

B Greatest common divisor

C Prime factorization

D Fibonacci sequence

The juggling algorithm divides the array into sets based on the greatest common divisor (GCD) of the array size and rotation count.

Why do we use modulo operation in array rotation?

A To reverse the array

B To increase the rotation count

C To sort the array

D To handle rotation counts larger than array size

Modulo operation wraps the rotation count within the array length to avoid unnecessary full rotations.

Explain how the reversal algorithm rotates an array step-by-step.

Think about reversing segments to move elements.

Describe the juggling algorithm and how it uses the greatest common divisor.

Focus on dividing the array into cycles.

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