Array Rotation Techniques in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to rotate the array to the left by one position.

DSA C++

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

Drag options to blanks, or click blank then click option'

A/

B-

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' instead of '+' causes accessing wrong indices.

Using '*' or '/' operators are invalid for indexing.

To shift elements left, we assign arr[i] = arr[i + 1]. So the operator is '+'.

2fill in blank

medium

Complete the code to rotate the array to the right by one position.

DSA C++

void rotateRightByOne(int arr[], int n) {
    int temp = arr[n - 1];
    for (int i = n - 1; i > 0; i--) {
        arr[i] = arr[i [1] 1];
    }
    arr[0] = temp;
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '-' causes out-of-bound errors.

Using '*' or '/' operators are invalid for indexing.

To shift elements right, we assign arr[i] = arr[i - 1]. So the operator is '-'.

3fill in blank

hard

Fix the error in the code to rotate the array left by d positions using reversal algorithm.

DSA C++

void reverse(int arr[], int start, int end) {
    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start [1] 1;
        end [2] 1;
    }
}

void rotateLeft(int arr[], int n, int d) {
    d = d % n;
    reverse(arr, 0, d - 1);
    reverse(arr, d, n - 1);
    reverse(arr, 0, n - 1);
}

Drag options to blanks, or click blank then click option'

A+

B-

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' for both start and end causes infinite loop.

Using '-' for both causes no progress.

In the reverse function, use + to increment start and - to decrement end.

4fill in blank

hard

Fill both blanks to complete the code that rotates the array left by d positions using the juggling algorithm.

DSA C++

int gcd(int a, int b) {
    if (b == 0)
        return a;
    return gcd(b, a [1] b);
}

void rotateLeftJuggling(int arr[], int n, int d) {
    d = d % n;
    int g_c_d = gcd(n, d);
    for (int i = 0; i < g_c_d; i++) {
        int temp = arr[i];
        int j = i;
        while (true) {
            int k = j [2] d;
            if (k >= n)
                k = k - n;
            if (k == i)
                break;
            arr[j] = arr[k];
            j = k;
        }
        arr[j] = temp;
    }
}

Drag options to blanks, or click blank then click option'

A%

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '%' in gcd causes infinite recursion.

Using '-' instead of '+' in index update causes wrong rotation.

The gcd function uses modulo operator '%'. In the juggling algorithm, we move index by adding d, so '+' is used.

5fill in blank

hard

Fill all three blanks to complete the code that creates a dictionary mapping each element to its rotated position after left rotation by d.

DSA C++

std::unordered_map<int, int> rotatedPositions(const std::vector<int>& arr, int d) {
    int n = arr.size();
    std::unordered_map<int, int> posMap;
    for (int i = 0; i < n; i++) {
        int newPos = (i [1] d) [2] n;
        if (newPos < 0) {
            newPos[3]=n;
        }
        posMap[arr[i]] = newPos;
    }
    return posMap;
}

Drag options to blanks, or click blank then click option'

A-

B%

C+

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '-' causes wrong positions.

Not handling negative indices causes errors.

To find new position after left rotation by d, we subtract d from i, then take modulo n. If result is negative, add n to wrap around.

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