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 array after performing a left rotation by 2 positions?

DSA C

int arr[] = {10, 20, 30, 40, 50};
int n = 5, d = 2;
// Left rotate by d
int rotated[5];
for(int i = 0; i < n; i++) {
    rotated[i] = arr[(i + d) % n];
}
for(int i = 0; i < n; i++) {
    printf("%d ", rotated[i]);
}

A 20 30 40 50 10

B 40 50 10 20 30

C 30 40 50 10 20

D 50 10 20 30 40

💡 Hint

Think about moving the first two elements to the end.

Left rotation by 2 moves elements at index 0 and 1 to the end, so the array starts from index 2.

❓ Predict Output

intermediate

Output of Right Rotation by 3

What is the output of the array after performing a right rotation 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++) {
    printf("%d ", rotated[i]);
}

A 6 1 2 3 4 5

B 4 5 6 1 2 3

C 3 4 5 6 1 2

D 5 6 1 2 3 4

💡 Hint

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

Right rotation by 3 shifts elements so that the last 3 elements come to the front.

🔧 Debug

advanced

Identify the Error in Rotation Code

What error will this code produce when trying to left rotate an array 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];
}
for(int i = 0; i < n; i++) {
    printf("%d ", rotated[i]);
}

A No error, output: 8 9 10 7

B Array index out of bounds error

C Output: 7 8 9 10

D Compilation error due to invalid syntax

💡 Hint

Consider how modulo operator handles d greater than n.

Modulo operator ensures index wraps correctly even if d > n, so no error occurs.

❓ Predict Output

advanced

Output of Reversal Algorithm for Left Rotation

What is the output of the array after left rotating by 3 using the 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++;
        end--;
    }
}

int arr[] = {1, 2, 3, 4, 5, 6, 7};
int n = 7, d = 3;
reverse(arr, 0, d - 1);
reverse(arr, d, n - 1);
reverse(arr, 0, n - 1);
for(int i = 0; i < n; i++) {
    printf("%d ", arr[i]);
}

A 4 5 6 7 1 2 3

B 7 6 5 4 3 2 1

C 5 6 7 1 2 3 4

D 3 2 1 7 6 5 4

💡 Hint

Reversal algorithm reverses parts then whole array.

First reverse first 3 elements, then last 4, then whole array to get left rotation by 3.

🧠 Conceptual

expert

Minimum Number of Rotations to Restore Original Array

Given an array of length n, what is the minimum number of left rotations needed to restore the array to its original order?

A 0

B 1

C n - 1

D n

💡 Hint

Think about how many times you must rotate to get back to start.

Rotating n times brings every element back to its original position.

Practice

1. What does a left rotation by 1 position do to the array [1, 2, 3, 4, 5]?

easy

A. Moves the last element to the front, resulting in [5, 1, 2, 3, 4]

B. Moves the first element to the end, resulting in [2, 3, 4, 5, 1]

C. Reverses the array, resulting in [5, 4, 3, 2, 1]

D. Leaves the array unchanged

Solution

1. Step 1: Understand left rotation by 1

   Left rotation by 1 means the first element moves to the end, and all others shift left by one.

2. Step 2: Apply rotation to the array

   Starting with [1, 2, 3, 4, 5], after rotation it becomes [2, 3, 4, 5, 1].

3. Final Answer:

   Moves the first element to the end, resulting in [2, 3, 4, 5, 1] -> Option B

4. Quick Check:

   Left rotate by 1 shifts left, first element goes last [OK]

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

Common Mistakes:

• Confusing left rotation with right rotation
• Thinking rotation reverses the array
• Assuming array stays the same

2. Which of the following is the correct C syntax to rotate an array arr of size n to the right by 1 position using a temporary variable temp?

easy

A. temp = arr[n-1]; for (int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = temp;

B. temp = arr[0]; for (int i = 0; i < n-1; i++) arr[i] = arr[i+1]; arr[n-1] = temp;

C. temp = arr[n]; for (int i = n; i > 0; i--) arr[i] = arr[i-1]; arr[0] = temp;

D. temp = arr[1]; for (int i = 1; i < n; i++) arr[i] = arr[i-1]; arr[0] = temp;

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 moves the last element to the front, shifting others right.

2. Step 2: Check syntax correctness

   temp = arr[n-1]; for (int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = temp; saves last element arr[n-1], shifts elements from right to left, then sets arr[0] = temp. This matches right rotation logic.

3. Final Answer:

   temp = arr[n-1]; for (int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = temp; -> Option A

4. Quick Check:

   Right rotate saves last, shifts right, places last at front [OK]

Hint: Right rotate saves last element, shifts right, places last front [OK]

Common Mistakes:

• Using wrong index for temp (like arr[n])
• Loop direction incorrect (should go backward for right rotate)
• Shifting elements in wrong direction

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

int arr[] = {10, 20, 30, 40, 50};
int n = 5, d = 2;
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;
}
for (int i = 0; i < n; i++) printf("%d ", arr[i]);

medium

A. 30 40 50 10 20

B. 40 50 10 20 30

C. 20 30 40 50 10

D. 50 10 20 30 40

Solution

1. Step 1: Understand the code logic

   The code performs left rotation by 1, two times (d=2). Each rotation moves first element to end.

2. Step 2: Trace rotations step-by-step

   Initial: [10, 20, 30, 40, 50]
   After 1st rotation: [20, 30, 40, 50, 10]
   After 2nd rotation: [30, 40, 50, 10, 20]

3. Final Answer:

   30 40 50 10 20 -> Option A

4. Quick Check:

   Left rotate twice shifts first two elements to end [OK]

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

Common Mistakes:

• Confusing left and right rotation
• Rotating only once instead of d times
• Off-by-one errors in loops

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

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

medium

A. No error, code works correctly

B. Loop should start from i = 0 instead of 1

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

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

Solution

1. Step 1: Analyze array indexing

   Array indices go from 0 to n-1. Accessing arr[n] is outside valid range.

2. Step 2: Identify error in assignment

   Assigning arr[n] = temp causes out-of-bounds write, which is invalid and unsafe.

3. Final Answer:

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

4. Quick Check:

   Array index must be less than n [OK]

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

Common Mistakes:

• Using arr[n] instead of arr[n-1]
• Starting loop at wrong index
• Confusing left and right rotation logic

5. Given an array arr = [1, 2, 3, 4, 5, 6] and a rotation count d = 8, what will be the array after left rotating by d positions?

hard

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

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

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

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

Solution

1. Step 1: Calculate effective rotation

   Since rotating by d = 8 on array size n = 6, effective rotation = d % n = 8 % 6 = 2.

2. Step 2: Rotate array left by 2 positions

   Left rotating [1, 2, 3, 4, 5, 6] by 2 gives [3, 4, 5, 6, 1, 2].

3. Final Answer:

   [3, 4, 5, 6, 1, 2] -> Option C

4. Quick Check:

   Rotation count modulo array size gives effective rotation [OK]

Hint: Use d % n to find effective rotation count [OK]

Common Mistakes:

• Rotating by d without modulo causes wrong result
• Confusing left and right rotation
• Assuming array unchanged if d > n