Array Rotation Techniques in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2

What is the output of the following Java code after rotating the array left by 2 positions?

DSA Java

public class Main {
    public static void main(String[] args) {
        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];
        }
        for (int val : rotated) {
            System.out.print(val + " ");
        }
    }
}

A [20, 30, 40, 50, 10]

B [40, 50, 10, 20, 30]

C [50, 10, 20, 30, 40]

D [30, 40, 50, 10, 20]

💡 Hint

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

Rotating left by 2 means elements move 2 positions to the left. The element at index 0 moves to index n-2, and so on. The code uses modulo to wrap around.

❓ Predict Output

intermediate

Output of Right Rotation by 3

What is the output of the following Java code after rotating the array right by 3 positions?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6};
        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];
        }
        for (int val : rotated) {
            System.out.print(val + " ");
        }
    }
}

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

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

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

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

💡 Hint

Right rotation moves elements to the right by d positions.

Each element moves d positions forward. Using modulo ensures wrapping around the array.

🧠 Conceptual

advanced

Time Complexity of Rotation by Reversal Algorithm

What is the time complexity of rotating an array of size n by d positions using the reversal algorithm?

A O(n)

B O(d)

C O(n*d)

D O(log n)

💡 Hint

The reversal algorithm involves reversing parts of the array multiple times.

The reversal algorithm reverses the first d elements, then the rest, then the whole array. Each reversal is O(k) where k is the length reversed. Total is O(n).

🔧 Debug

advanced

Identify the Bug in Rotation Code

What error will the following Java code produce when rotating an array left by d positions?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {7, 8, 9, 10};
        int d = 5;
        int n = arr.length;
        int[] rotated = new int[n];
        for (int i = 0; i < n; i++) {
            rotated[i] = arr[(i + d)];
        }
        for (int val : rotated) {
            System.out.print(val + " ");
        }
    }
}

A Compilation error

B ArrayIndexOutOfBoundsException

C No error, outputs [8, 9, 10, 7]

D NullPointerException

💡 Hint

Check how the index is calculated inside the loop.

The code accesses arr[i + d] without modulo, so when i + d >= n, it causes ArrayIndexOutOfBoundsException.

🚀 Application

expert

Minimum Rotations to Match Arrays

Given two arrays A and B of the same size n, what is the minimum number of left rotations needed on A to make it equal to B? If not possible, return -1. Which approach is best to solve this efficiently?

A Concatenate A with itself and check if B is a substring; if yes, the index is the rotation count.

B Sort both arrays and compare; if equal, rotation count is the difference of first elements.

C Rotate A one by one up to n times and compare each time with B.

D Use a hash map to store elements and find rotation count by difference of indices.

💡 Hint

Think about how rotations relate to substrings in concatenated arrays.

Concatenating A with itself contains all rotations of A as substrings. Checking if B is substring gives rotation count efficiently in O(n).

Practice

1. What does rotating an array to the left by 1 position mean?
Example: [1, 2, 3, 4] rotated left by 1 becomes?

easy

A. [2, 3, 4, 1]

B. [4, 1, 2, 3]

C. [1, 4, 3, 2]

D. [3, 4, 1, 2]

Solution

1. Step 1: Understand left rotation

   Left rotation by 1 means each element moves one step to the left, and the first element moves to the end.

2. Step 2: Apply left rotation on example

   For [1, 2, 3, 4], after left rotation by 1, it becomes [2, 3, 4, 1].

3. Final Answer:

   [2, 3, 4, 1] -> Option A

4. Quick Check:

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

Hint: Left rotate shifts elements left, first goes to last [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Not moving the first element to the end
• Shifting elements in the wrong direction

2. Which of the following Java code snippets correctly rotates an array arr of length n to the right by 1 position?

easy

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

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

C. for(int i = 0; i < n; i++) arr[i] = arr[(i+1) % n];

D. int temp = arr[0]; arr[0] = arr[n-1]; arr[n-1] = temp;

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 moves each element one step right, last element moves to first position.

2. Step 2: Check code correctness

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

3. Final Answer:

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

4. Quick Check:

   Right rotate shifts right, last to first [OK]

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

Common Mistakes:

• Using left rotation logic for right rotation
• Incorrect loop direction causing overwrite
• Swapping only first and last elements

3. What is the output of the following Java code?

int[] arr = {10, 20, 30, 40, 50};
int d = 2;
for(int i = 0; i < d; i++) {
    int temp = arr[0];
    for(int j = 0; j < arr.length - 1; j++) {
        arr[j] = arr[j+1];
    }
    arr[arr.length - 1] = temp;
}
System.out.println(java.util.Arrays.toString(arr));

medium

A. [20, 30, 40, 50, 10]

B. [30, 40, 50, 10, 20]

C. [50, 10, 20, 30, 40]

D. [10, 20, 30, 40, 50]

Solution

1. Step 1: Understand the loop rotates array left by 1, repeated d times

   Each iteration moves first element to end, shifting left by 1. Loop runs twice (d=2).

2. Step 2: Trace array after each rotation

   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 B

4. Quick Check:

   Left rotate by 2 shifts first 2 elements to end [OK]

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

Common Mistakes:

• Confusing left and right rotation
• Not repeating rotation d times
• Off-by-one errors in loops

4. Identify the error in this Java code that attempts to rotate an array arr of length n to the left by 1:

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

medium

A. temp should be assigned after the loop

B. Array length n is incorrect

C. Loop runs out of bounds accessing arr[n]

D. No error, code is correct

Solution

1. Step 1: Analyze the loop range and array access

   The loop runs from i=0 to i=n-1, but inside it accesses arr[i+1]. For i=n-1, arr[i+1] = arr[n], which is out of bounds.

2. Step 2: Identify the cause of error

   Accessing arr[n] causes ArrayIndexOutOfBoundsException. The loop should run only till i < n-1.

3. Final Answer:

   Loop runs out of bounds accessing arr[n] -> Option C

4. Quick Check:

   Array index must be within 0 to n-1 [OK]

Hint: Check array indices carefully to avoid out-of-bounds [OK]

Common Mistakes:

• Looping till i < n instead of i < n-1
• Ignoring array length limits
• Misplacing temp assignment

5. Given an array arr = [5, 10, 15, 20, 25, 30], how can you rotate it to the right by 3 positions efficiently without using extra space?

hard

A. Swap elements pairwise from start to end 3 times

B. Shift elements one by one to the right 3 times using nested loops

C. Copy last 3 elements to a temp array, shift rest right, then copy temp to front

D. Reverse entire array, reverse first 3 elements, then reverse remaining elements

Solution

1. Step 1: Understand the reversal algorithm for rotation

   To rotate right by d, reverse whole array, then reverse first d elements, then reverse remaining n-d elements.

2. Step 2: Apply to example

   Array: [5,10,15,20,25,30]
   Reverse all: [30,25,20,15,10,5]
   Reverse first 3: [20,25,30,15,10,5]
   Reverse last 3: [20,25,30,5,10,15]

3. Final Answer:

   Reverse entire array, reverse first 3 elements, then reverse remaining elements -> Option D

4. Quick Check:

   Reversal method rotates array efficiently without extra space [OK]

Hint: Use reversal method: reverse all, then parts [OK]

Common Mistakes:

• Using extra space instead of in-place reversal
• Shifting elements one by one inefficiently
• Incorrect order of reversals