Array Rotation Techniques in DSA C# - Execution Trace

Concept Flow - Array Rotation Techniques

Start with array

↓

Choose rotation direction

↓

Left Rotate

↓

Shift elements

↓

Wrap around elements

↓

Result: rotated array

This flow shows how an array is rotated either left or right by shifting elements and wrapping around the ends.

Execution Sample

DSA C#

int[] arr = {1, 2, 3, 4, 5};
int d = 2; // rotate left by 2
RotateLeft(arr, d);
// Result: 3, 4, 5, 1, 2

Rotate the array left by 2 positions, moving the first two elements to the end.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Initial array	[1, 2, 3, 4, 5]	head=0	1 -> 2 -> 3 -> 4 -> 5 -> null
2	Rotate left by 1 (first rotation)	[2, 3, 4, 5, 1]	head moves right by 1	2 -> 3 -> 4 -> 5 -> 1 -> null
3	Rotate left by 2 (second rotation)	[3, 4, 5, 1, 2]	head moves right by 1 again	3 -> 4 -> 5 -> 1 -> 2 -> null
4	Rotation complete	[3, 4, 5, 1, 2]	head at index 2	3 -> 4 -> 5 -> 1 -> 2 -> null

💡 Rotation count reached 2, array rotated left by 2 positions

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
arr	[1, 2, 3, 4, 5]	[2, 3, 4, 5, 1]	[3, 4, 5, 1, 2]	[3, 4, 5, 1, 2]
d	2	2	2	2
head	0	1	2	2

Key Moments - 3 Insights

Why does the array look different after each rotation step?

Each rotation shifts elements by one position and moves the first element to the end, as shown in steps 2 and 3 of the execution_table.

What happens if rotation count is zero or equal to array length?

If rotation count is zero or equal to array length, the array remains unchanged because the elements wrap around fully, no net change occurs.

Why do we track 'head' pointer in rotation?

Tracking 'head' helps visualize which element is considered the start after rotations, as seen in the pointer changes column in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after the first rotation step?

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

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

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

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

💡 Hint

Check the 'Array State' column at Step 2 in the execution_table.

At which step does the 'head' pointer move to index 2?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Pointer Changes' column in the execution_table.

If we rotate left by 0, what will be the final array state?

A Same as initial array

B Array reversed

C Array rotated by 1

D Empty array

💡 Hint

Refer to key_moments about rotation count zero and its effect.

Concept Snapshot

Array Rotation Techniques:
- Rotate array left or right by shifting elements
- Left rotate: move first elements to end
- Right rotate: move last elements to front
- Rotation count modulo array length
- Track start index (head) for visualization

Full Transcript

This lesson shows how to rotate an array left or right by shifting elements step-by-step. We start with the original array and move elements one by one, wrapping around the ends. The 'head' pointer tracks the new start after each rotation. Rotating left by 2 moves the first two elements to the end, resulting in a new order. If rotation count is zero or equal to array length, the array stays the same. The execution table traces each step's array state and pointer changes, helping visualize the process clearly.

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