Array Reversal Techniques in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Array Reversal Using Two Pointers

What is the output of the following Java code that reverses an array using two pointers?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

A 5 2 3 4 1

B 1 2 3 4 5

C 5 4 3 2 1

D 1 5 3 2 4

💡 Hint

Think about how swapping elements from start and end moves towards the center.

The code swaps elements from the start and end moving inward, effectively reversing the array.

❓ Predict Output

intermediate

Output of Array Reversal Using Recursion

What is the output of this Java code that reverses an array recursively?

DSA Java

public class Main {
    public static void reverse(int[] arr, int start, int end) {
        if (start >= end) return;
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        reverse(arr, start + 1, end - 1);
    }
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};
        reverse(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

A 10 40 30 20

B 40 30 20 10

C 10 20 30 40

D 40 20 30 10

💡 Hint

Recursion swaps outer elements and moves inward.

The recursive function swaps elements at start and end indices until they meet or cross, reversing the array.

🔧 Debug

advanced

Identify the Error in Array Reversal Code

What error will this Java code produce when trying to reverse an array?

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4};
        for (int i = 0; i <= arr.length / 2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

A ArrayIndexOutOfBoundsException

B No output, code runs correctly

C NullPointerException

D Compilation error due to missing semicolon

💡 Hint

Check the index used for swapping elements.

The code accesses arr[arr.length - i], which is out of bounds since array indices go from 0 to length-1.

🧠 Conceptual

advanced

Time Complexity of Array Reversal

What is the time complexity of reversing an array of size n using the two-pointer swapping method?

A O(n)

B O(n^2)

C O(log n)

D O(1)

💡 Hint

Consider how many swaps are done relative to the array size.

Each element is swapped at most once, so the operation scales linearly with n.

❓ Predict Output

expert

Output of Reversing Array Using Streams (Java 8+)

What is the output of this Java code that reverses an array using streams?

DSA Java

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr = {3, 6, 9, 12};
        int[] reversed = Arrays.stream(arr)
            .boxed()
            .sorted((a, b) -> b - a)
            .mapToInt(Integer::intValue)
            .toArray();
        for (int num : reversed) {
            System.out.print(num + " ");
        }
    }
}

A 9 12 6 3

B Compilation error due to missing import

C 3 6 9 12

D 12 9 6 3

💡 Hint

The sorted comparator reverses the order.

The stream boxes ints to Integers, sorts them in descending order, then converts back to int array.

Practice

1. What does reversing an array mean in simple terms?

easy

A. Changing the order of elements so the last becomes first and first becomes last

B. Sorting the array in ascending order

C. Removing duplicate elements from the array

D. Adding new elements at the end of the array

Solution

1. Step 1: Understand array reversal meaning

   Reversing means flipping the order of elements so the last element comes first and the first element comes last.

2. Step 2: Compare with other options

   Sorting arranges elements by value, removing duplicates deletes repeated items, and adding elements is insertion, not reversal.

3. Final Answer:

   Changing the order of elements so the last becomes first and first becomes last -> Option A

4. Quick Check:

   Reversal = Flip order [OK]

Hint: Reversal flips array ends, not sorting or removing [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Mixing reversal with adding elements

2. Which of the following Java code snippets correctly reverses an integer array arr in-place?

easy

A. for(int i = arr.length - 1; i >= 0; i--) { System.out.print(arr[i]); }

B. for(int i = 0; i < arr.length; i++) { arr[i] = arr[arr.length - 1 - i]; }

C. for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; }

D. Arrays.sort(arr);

Solution

1. Step 1: Analyze in-place reversal logic

   for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } swaps elements from start and end moving towards center, correctly reversing the array in-place.

2. Step 2: Check other options

   for(int i = 0; i < arr.length; i++) { arr[i] = arr[arr.length - 1 - i]; } overwrites elements incorrectly, for(int i = arr.length - 1; i >= 0; i--) { System.out.print(arr[i]); } only prints reversed array without changing it, Arrays.sort(arr); sorts array, not reverses.

3. Final Answer:

   for(int i = 0; i < arr.length / 2; i++) { int temp = arr[i]; arr[i] = arr[arr.length - 1 - i]; arr[arr.length - 1 - i] = temp; } -> Option C

4. Quick Check:

   Swap pairs from ends = reversal [OK]

Hint: Swap pairs from ends up to middle for reversal [OK]

Common Mistakes:

• Overwriting elements without swapping
• Only printing reversed array without changing it
• Using sort instead of reversal

3. What will be the output of the following Java code?

int[] arr = {1, 2, 3, 4, 5};
for(int i = 0; i < arr.length / 2; i++) {
  int temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}
for(int num : arr) {
  System.out.print(num + " ");
}

medium

A. 5 4 3 2 1

B. 1 2 3 4 5

C. 5 2 3 4 1

D. 1 4 3 2 5

Solution

1. Step 1: Trace the reversal loop

   The loop swaps arr[0] with arr[4], arr[1] with arr[3]. After swaps, array becomes [5,4,3,2,1].

2. Step 2: Print the array elements

   The print loop outputs elements in order: 5 4 3 2 1

3. Final Answer:

   5 4 3 2 1 -> Option A

4. Quick Check:

   Swapped ends = reversed array [OK]

Hint: Swapping ends reverses array; print shows reversed order [OK]

Common Mistakes:

• Not swapping correctly, leaving array unchanged
• Confusing print output with original array
• Off-by-one errors in loop

4. Identify the error in the following Java code that attempts to reverse an array arr:

for(int i = 0; i <= arr.length / 2; i++) {
  int temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}

medium

A. The temp variable should be declared outside the loop

B. The loop condition should be 'i < arr.length / 2' to avoid swapping middle element twice

C. The swap logic is incorrect; it should swap arr[i] with arr[i+1]

D. The loop should run from 'i = arr.length - 1' down to 0

Solution

1. Step 1: Analyze loop condition

   The loop uses 'i <= arr.length / 2', which causes the middle element to be swapped twice when array length is odd.

2. Step 2: Correct loop condition

   Changing condition to 'i < arr.length / 2' ensures swaps happen only once per pair, avoiding double swap of middle element.

3. Final Answer:

   The loop condition should be 'i < arr.length / 2' to avoid swapping middle element twice -> Option B

4. Quick Check:

   Loop limit excludes middle for odd length [OK]

Hint: Use '<' not '<=' to avoid double swapping middle element [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Declaring temp outside loop unnecessarily
• Incorrect swap logic swapping wrong elements

5. Given a 2D integer array matrix of size n x n, which code snippet correctly reverses each row of the matrix in-place?

hard

A. for(int i = 0; i < n; i++) { Arrays.sort(matrix[i]); }

B. for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { matrix[i][j] = matrix[i][n - 1 - j]; } }

C. for(int j = 0; j < n; j++) { for(int i = 0; i < n / 2; i++) { int temp = matrix[i][j]; matrix[i][j] = matrix[n - 1 - i][j]; matrix[n - 1 - i][j] = temp; } }

D. for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } }

Solution

1. Step 1: Understand reversing each row

   Reversing each row means swapping elements in each row from start to end moving towards center.

2. Step 2: Analyze options

   for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } } swaps elements in each row correctly. for(int i = 0; i < n; i++) { for(int j = 0; j < n; j++) { matrix[i][j] = matrix[i][n - 1 - j]; } } overwrites elements incorrectly. for(int j = 0; j < n; j++) { for(int i = 0; i < n / 2; i++) { int temp = matrix[i][j]; matrix[i][j] = matrix[n - 1 - i][j]; matrix[n - 1 - i][j] = temp; } } swaps columns, not rows. for(int i = 0; i < n; i++) { Arrays.sort(matrix[i]); } sorts rows, not reverses.

3. Final Answer:

   for(int i = 0; i < n; i++) { for(int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } } -> Option D

4. Quick Check:

   Swap pairs in each row for reversal [OK]

Hint: Reverse each row by swapping pairs from ends to center [OK]

Common Mistakes:

• Swapping columns instead of rows
• Overwriting elements without swapping
• Sorting rows instead of reversing