Array Reversal Techniques in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this array reversal code?

Consider the following JavaScript code that reverses an array. What will be printed?

DSA Javascript

const arr = [1, 2, 3, 4, 5];
for(let i = 0; i < arr.length / 2; i++) {
  const temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}
console.log(arr);

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

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

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

D [undefined, undefined, undefined, undefined, undefined]

💡 Hint

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

The code swaps elements from the start and end of the array moving towards the center, effectively reversing the array in place.

❓ Predict Output

intermediate

What is the output of this code using built-in reverse?

What will be the output of this JavaScript code snippet?

DSA Javascript

const arr = ['a', 'b', 'c', 'd'];
const reversed = arr.reverse();
console.log(reversed);
console.log(arr);

A ['d', 'c', 'b', 'a'] and ['a', 'b', 'c', 'd']

B ['d', 'c', 'b', 'a'] and ['d', 'c', 'b', 'a']

C ['a', 'b', 'c', 'd'] and ['a', 'b', 'c', 'd']

D ['a', 'b', 'c', 'd'] and ['d', 'c', 'b', 'a']

💡 Hint

Remember that reverse() modifies the original array and returns it.

The reverse() method reverses the array in place and returns the same array. So both reversed and arr refer to the reversed array.

❓ Predict Output

advanced

What is the output of this recursive array reversal function?

Analyze the following recursive function that reverses an array. What will be printed?

DSA Javascript

function reverseArray(arr) {
  if (arr.length === 0) return [];
  return [arr.pop()].concat(reverseArray(arr));
}
const original = [1, 2, 3];
const reversed = reverseArray(original.slice());
console.log(reversed);

A TypeError

B [1, 2, 3]

C [3, 1, 2]

D [3, 2, 1]

💡 Hint

The function removes the last element and adds it to the front recursively.

The function pops the last element and concatenates it with the reversed rest recursively, producing a reversed array.

❓ Predict Output

advanced

What is the output of this code reversing a linked list represented as an array of nodes?

Given the array representing a singly linked list nodes, what will be the output after reversal?

DSA Javascript

const nodes = [
  {value: 1, next: 1},
  {value: 2, next: 2},
  {value: 3, next: null}
];
function reverseList(nodes) {
  let prev = null;
  let currentIndex = 0;
  while (currentIndex !== null) {
    const currentNode = nodes[currentIndex];
    const nextIndex = currentNode.next;
    currentNode.next = prev;
    prev = currentIndex;
    currentIndex = nextIndex;
  }
  return prev;
}
const newHead = reverseList(nodes);
const result = [];
let idx = newHead;
while (idx !== null) {
  result.push(nodes[idx].value);
  idx = nodes[idx].next;
}
console.log(result);

A [3, 2, 1]

B Infinite loop

C [1, 3, 2]

D [1, 2, 3]

💡 Hint

The code reverses the linked list by changing next pointers.

The while loop reverses the next pointers of each node, so the list order becomes 3 -> 2 -> 1.

🧠 Conceptual

expert

Which statement about array reversal time complexity is correct?

Consider reversing an array of length n. Which statement below correctly describes the time complexity of reversing the array in place?

A Reversing the array in place takes O(n) time because each element is swapped once.

B Reversing the array in place takes O(n^2) time because each element is compared with every other element.

C Reversing the array in place takes O(log n) time because the array is divided recursively.

D Reversing the array in place takes O(1) time because it only swaps the first and last elements.

💡 Hint

Think about how many swaps happen when reversing an array.

Each element is swapped once with its counterpart, so the total operations scale linearly with n.

Practice

1. What does the reverse() method do to an array in JavaScript?

easy

A. It removes duplicate elements from the array.

B. It sorts the array in ascending order.

C. It reverses the order of elements in the original array.

D. It creates a new array with elements doubled.

Solution

1. Step 1: Understand the reverse() method

   The reverse() method changes the original array by reversing the order of its elements.

2. Step 2: Confirm the effect on the original array

   It does not create a new array or sort; it simply reverses the existing array in place.

3. Final Answer:

   It reverses the order of elements in the original array. -> Option C

4. Quick Check:

   reverse() = reverses array order [OK]

Hint: reverse() flips array order in place [OK]

Common Mistakes:

• Thinking reverse() sorts the array
• Assuming reverse() creates a new array
• Confusing reverse() with removing duplicates

2. Which of the following is the correct syntax to reverse an array named arr in JavaScript?

easy

A. arr.reverse();

B. reverse(arr);

C. arr = reverse();

D. arr.reverse(arr);

Solution

1. Step 1: Identify the method call syntax

   The reverse() method is called on the array object itself, so the syntax is arr.reverse();.

2. Step 2: Check other options for errors

   Options A, B, and C are incorrect because reverse is not a standalone function and does not take arguments.

3. Final Answer:

   arr.reverse(); -> Option A

4. Quick Check:

   Method called on array object = arr.reverse() [OK]

Hint: Use arrayName.reverse() to reverse in place [OK]

Common Mistakes:

• Calling reverse as a standalone function
• Passing the array as an argument to reverse
• Assigning reverse() without calling on array

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

const arr = [1, 2, 3, 4];
const reversed = arr.reverse();
console.log(reversed);

medium

A. undefined

B. [1, 2, 3, 4]

C. [1, 4, 3, 2]

D. [4, 3, 2, 1]

Solution

1. Step 1: Understand reverse() return value

   The reverse() method reverses the original array and returns the same reversed array.

2. Step 2: Trace the code output

   After calling arr.reverse(), arr becomes [4, 3, 2, 1], and reversed holds this reversed array. Logging reversed prints [4, 3, 2, 1].

3. Final Answer:

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

4. Quick Check:

   reverse() returns reversed array [OK]

Hint: reverse() returns the reversed array itself [OK]

Common Mistakes:

• Expecting original array unchanged
• Thinking reverse() returns undefined
• Confusing reverse() with sorting

4. Find the error in the following code that tries to reverse an array nums:

function reverseArray(nums) {
  for(let i = 0; i < nums.length / 2; i++) {
    let temp = nums[i];
    nums[i] = nums[nums.length - i];
    nums[nums.length - i] = temp;
  }
  return nums;
}

medium

A. The index nums.length - i is out of bounds; should be nums.length - i - 1.

B. The temp variable is not needed for swapping.

C. The loop should run while i < nums.length / 2, not <=.

D. The function should return a new array, not modify nums.

Solution

1. Step 1: Check index calculations for swapping

   The code uses nums.length - i as the index for the element to swap, but array indices go from 0 to nums.length - 1, so it should be nums.length - i - 1.

2. Step 2: Confirm loop condition and swapping logic

   The loop condition i < nums.length / 2 is acceptable, and temp is needed for swapping. Modifying the original array is allowed here.

3. Final Answer:

   The index nums.length - i is out of bounds; should be nums.length - i - 1. -> Option A

4. Quick Check:

   Array indices start at 0, so subtract 1 [OK]

Hint: Array last index = length - 1, not length [OK]

Common Mistakes:

• Using nums.length - i instead of nums.length - i - 1
• Removing temp variable causing swap errors
• Incorrect loop boundary causing extra swaps

5. Given an array arr, which code snippet correctly reverses the array without modifying the original array?

hard

A. const reversed = arr.reverse();

B. const reversed = arr.slice().reverse();

C. const reversed = [...arr].sort().reverse();

D. const reversed = arr.reverse().map(x => x);

Solution

1. Step 1: Understand how to avoid modifying original array

   Using arr.slice() creates a shallow copy of the array. Calling reverse() on this copy reverses it without changing the original.

2. Step 2: Analyze other options

   const reversed = arr.reverse(); reverses the original array. const reversed = [...arr].sort().reverse(); sorts before reversing, changing order. const reversed = arr.reverse().map(x => x); reverses the original array because reverse() is called on arr before mapping.

3. Final Answer:

   const reversed = arr.slice().reverse(); -> Option B

4. Quick Check:

   Copy then reverse to keep original safe [OK]

Hint: Use slice() to copy before reverse() [OK]

Common Mistakes:

• Using reverse() directly modifies original array
• Sorting before reversing changes order
• Thinking reverse().map(x => x) preserves original array