Array Reversal Techniques in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to reverse the array using a simple loop.

DSA Java

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

Drag options to blanks, or click blank then click option'

Aarr.length

B1

C0

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed number instead of the loop variable.

Using the wrong index calculation causing ArrayIndexOutOfBoundsException.

The index to swap with is the mirror position from the end, which is arr.length - 1 - i.

2fill in blank

medium

Complete the code to reverse the array using two pointers.

DSA Java

int left = 0, right = arr.length - 1;
while (left < [1]) {
    int temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
    left++;
    right--;
}

Drag options to blanks, or click blank then click option'

Aright

Bleft

Carr.length

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong variable in the while condition.

Looping until left <= right causing unnecessary swaps.

The loop continues while left is less than right, swapping elements from both ends.

3fill in blank

hard

Fix the error in the recursive array reversal method by completing the base case condition.

DSA Java

void reverse(int[] arr, int start, int end) {
    if (start [1] end) {
        return;
    }
    int temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;
    reverse(arr, start + 1, end - 1);
}

Drag options to blanks, or click blank then click option'

A>=

B<=

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using start <= end which causes infinite recursion.

Using equality only, missing the case when start passes end.

The base case stops recursion when start is greater than or equal to end, meaning the array is fully reversed.

4fill in blank

hard

Fill both blanks to create a reversed copy of the array using a for loop.

DSA Java

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

Drag options to blanks, or click blank then click option'

Aarr.length

B1

C0

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using i instead of arr.length in the calculation.

Forgetting to subtract 1 causing index out of bounds.

The reversed index is calculated by subtracting the current index and 1 from the array length.

5fill in blank

hard

Fill all three blanks to reverse the array in place using a for loop with swapping.

DSA Java

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

Drag options to blanks, or click blank then click option'

Aarr.length

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using arr.length directly in the loop condition without dividing by 2.

Incorrect index calculation causing ArrayIndexOutOfBoundsException.

The loop runs till half the array length. The swap index is calculated as arr.length - i - 1.

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