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 rotating it left by 2 positions?

DSA C#

int[] arr = {1, 2, 3, 4, 5};
int d = 2;
int n = arr.Length;
int[] rotated = new int[n];
for (int i = 0; i < n; i++) {
    rotated[i] = arr[(i + d) % n];
}
Console.WriteLine(string.Join(", ", rotated));

A 4, 5, 1, 2, 3

B 5, 1, 2, 3, 4

C 2, 3, 4, 5, 1

D 3, 4, 5, 1, 2

💡 Hint

Think about how the index shifts when rotating left by 2.

Rotating left by 2 means the element at index 2 moves to index 0, index 3 to 1, and so on.

❓ Predict Output

intermediate

Output of Right Rotation by 3

What is the output of the array after rotating it right by 3 positions?

DSA C#

int[] arr = {10, 20, 30, 40, 50};
int d = 3;
int n = arr.Length;
int[] rotated = new int[n];
for (int i = 0; i < n; i++) {
    rotated[(i + d) % n] = arr[i];
}
Console.WriteLine(string.Join(", ", rotated));

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

Right rotation moves elements to higher indexes wrapping around.

Each element moves 3 positions to the right. Using modulo ensures wrapping.

🔧 Debug

advanced

Identify the Error in Rotation Code

What error does this code produce when rotating an array left by d positions?

DSA C#

int[] arr = {1, 2, 3, 4, 5};
int d = 7;
int n = arr.Length;
int[] rotated = new int[n];
for (int i = 0; i < n; i++) {
    rotated[i] = arr[((i - d) % n + n) % n];
}
Console.WriteLine(string.Join(", ", rotated));

A IndexOutOfRangeException

B Correct output: 3, 4, 5, 1, 2

C Negative index error

D Compilation error

💡 Hint

Check how modulo behaves with negative numbers in C#.

In C#, modulo with negative numbers can produce negative results, causing invalid array indexing.

🧠 Conceptual

advanced

Minimum Rotations to Restore Original Array

Given an array of length 6, how many left rotations are needed to restore the array to its original order?

A 3

B 6

C 1

D 0

💡 Hint

Think about rotating the array fully around.

Rotating the array by its length returns it to the original order.

🚀 Application

expert

Result of Multiple Rotations

What is the final array after performing these operations on [1, 2, 3, 4, 5]: rotate left by 2, then rotate right by 3?

DSA C#

int[] arr = {1, 2, 3, 4, 5};
int n = arr.Length;
int d1 = 2; // left rotation
int d2 = 3; // right rotation
int[] temp = new int[n];
for (int i = 0; i < n; i++) {
    temp[i] = arr[(i + d1) % n];
}
int[] result = new int[n];
for (int i = 0; i < n; i++) {
    result[(i + d2) % n] = temp[i];
}
Console.WriteLine(string.Join(", ", result));

A 4, 5, 1, 2, 3

B 1, 2, 3, 4, 5

C 5, 1, 2, 3, 4

D 2, 3, 4, 5, 1

💡 Hint

Combine the rotations carefully using modulo arithmetic.

Left rotation by 2 followed by right rotation by 3 equals a net right rotation of 1 position (3 - 2 = 1). The result is 5, 1, 2, 3, 4.

Practice

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

easy

A. Leaves the array unchanged

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

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

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

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 to given 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 D

4. Quick Check:

   Left rotation by 1 shifts left, first element to end [OK]

Hint: Left rotation moves front 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 C# code snippets correctly performs a right rotation by 1 on an integer array arr?

easy

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

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

C. Array.Reverse(arr);

D. Array.Sort(arr);

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 code snippets

   int last = arr[arr.Length - 1]; for (int i = arr.Length - 1; i > 0; i--) arr[i] = arr[i - 1]; arr[0] = last; saves last element, shifts elements right, then places last at front. This matches right rotation.

3. Final Answer:

   int last = arr[arr.Length - 1]; for (int i = arr.Length - 1; i > 0; i--) arr[i] = arr[i - 1]; arr[0] = last; -> Option A

4. Quick Check:

   Right rotation moves last element to front [OK]

Hint: Right rotation moves last element to front [OK]

Common Mistakes:

• Using left rotation code for right rotation
• Reversing array instead of rotating
• Sorting array instead of rotating

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

int[] arr = {10, 20, 30, 40, 50};
int d = 2;
int n = arr.Length;
int[] rotated = new int[n];
for (int i = 0; i < n; i++) {
  rotated[i] = arr[(i + d) % n];
}
Console.WriteLine(string.Join(", ", rotated));

medium

A. 40, 50, 10, 20, 30

B. 30, 40, 50, 10, 20

C. 50, 10, 20, 30, 40

D. 10, 20, 30, 40, 50

Solution

1. Step 1: Understand rotation logic in code

   Each element at index i in rotated is assigned arr[(i + d) % n], which means left rotation by d=2.

2. Step 2: Calculate rotated array elements

   For i=0: arr[(0+2)%5]=arr[2]=30
   i=1: arr[3]=40
   i=2: arr[4]=50
   i=3: arr[0]=10
   i=4: arr[1]=20
   Rotated array = [30, 40, 50, 10, 20]

3. Final Answer:

   30, 40, 50, 10, 20 -> Option B

4. Quick Check:

   Left rotation by 2 shifts elements left by 2 [OK]

Hint: Use modulo to wrap index for rotation [OK]

Common Mistakes:

• Confusing left and right rotation
• Forgetting modulo causes index error
• Misindexing array elements

4. The following code is intended to perform a left rotation by 3 on array arr. What is the error?

int[] arr = {1, 2, 3, 4, 5};
int d = 3;
int n = arr.Length;
int[] rotated = new int[n];
for (int i = 0; i < n; i++) {
  rotated[i] = arr[(i - d) % n];
}

medium

A. Using (i - d) % n causes negative index error

B. Loop should run from d to n

C. Array size is incorrect

D. Rotation direction is right instead of left

Solution

1. Step 1: Analyze index calculation

   The code uses (i - d) % n. When i < d, (i - d) is negative, so modulo gives negative result in C#.

2. Step 2: Understand modulo behavior in C#

   C# modulo with negative numbers returns negative values, causing invalid negative indices for array access.

3. Final Answer:

   Using (i - d) % n causes negative index error -> Option A

4. Quick Check:

   Negative modulo causes invalid array index [OK]

Hint: Add n before modulo to avoid negative indices [OK]

Common Mistakes:

• Ignoring negative modulo results
• Changing loop range incorrectly
• Confusing left and right rotation

5. Given an array arr = [4, 8, 15, 16, 23, 42], how would you perform a left rotation by d = 8 positions efficiently in C#?

hard

A. Reverse the array twice

B. Rotate by d positions directly without modulo

C. Rotate by d % arr.Length positions using a temporary array

D. Sort the array after rotation

Solution

1. Step 1: Understand rotation with d > array length

   Rotating by d=8 on array length 6 is same as rotating by d % 6 = 2 positions.

2. Step 2: Use modulo and temporary array

   Use d % n to find effective rotation, then rotate using a temporary array or in-place method.

3. Final Answer:

   Rotate by d % arr.Length positions using a temporary array -> Option C

4. Quick Check:

   Rotation by d mod length avoids unnecessary full rotations [OK]

Hint: Use d % array length to reduce rotations [OK]

Common Mistakes:

• Rotating by d without modulo wastes time
• Trying to sort array after rotation
• Using reverse without correct steps