Array Reversal Techniques in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of In-Place Array Reversal

What is the output of the following TypeScript code that reverses an array in place?

DSA Typescript

function reverseArray(arr: number[]): void {
  let left = 0;
  let right = arr.length - 1;
  while (left < right) {
    const temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
    left++;
    right--;
  }
}

const nums = [1, 2, 3, 4, 5];
reverseArray(nums);
console.log(nums);

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

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

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

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

💡 Hint

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

The function swaps elements from the start and end of the array moving inward, reversing the array in place.

❓ Predict Output

intermediate

Output of Array Reverse Using Built-in Method

What will be printed after running this TypeScript code that uses the built-in reverse method?

DSA Typescript

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

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

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

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

D ['d', 'c', 'b', 'a'] 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 reversed array, so both variables show the reversed array.

🔧 Debug

advanced

Identify the Error in Recursive Array Reversal

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

DSA Typescript

function recursiveReverse(arr: number[], start: number, end: number): void {
  if (start >= end) return;
  const temp = arr[start];
  arr[start] = arr[end];
  arr[end] = temp;
  recursiveReverse(arr, start + 1, end - 1);
}

const numbers = [10, 20, 30, 40];
recursiveReverse(numbers, 0, numbers.length - 1);
console.log(numbers);

A Stack overflow error due to infinite recursion

B No error, output: [40, 30, 20, 10]

C No error, output: [40, 20, 30, 10]

D TypeError due to wrong parameter types

💡 Hint

Trace the recursive calls step by step.

No error occurs. The code correctly reverses the array to [40, 30, 20, 10]. The base case start >= end terminates recursion properly after the pointers cross or meet.

❓ Predict Output

advanced

Output of Array Reversal Using Spread and Reduce

What is the output of this TypeScript code that reverses an array using spread operator and reduce?

DSA Typescript

const original = [1, 2, 3, 4];
const reversed = [...original].reduce((acc, val) => [val, ...acc], []);
console.log(reversed);

A [4, 3, 2, 1]

B [1, 4, 2, 3]

C [1, 2, 3, 4]

D []

💡 Hint

The reduce function builds a new array by adding current value at the front.

The reduce starts with empty array and prepends each element, effectively reversing the array.

🧠 Conceptual

expert

Time Complexity of Different Array Reversal Techniques

Which statement correctly describes the time complexity of reversing an array of size n using an in-place swap method versus creating a new reversed array?

A Both methods have O(1) time complexity

B In-place swap is O(n^2), creating a new reversed array is O(n)

C Both in-place swap and creating a new reversed array have O(n) time complexity

D In-place swap is O(n), creating a new reversed array is O(n^2)

💡 Hint

Consider how many times each element is accessed or moved.

Both methods visit each element once, so both run in linear time O(n).

Practice

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

easy

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

B. It sorts the array in ascending order.

C. It removes duplicate elements from the array.

D. It creates a new array with elements doubled.

Solution

1. Step 1: Understand the reverse() method

   The reverse() method changes the order of elements in the array so the last element becomes first and the first becomes last.

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

   This method modifies the original array itself, not creating a new one.

3. Final Answer:

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

4. Quick Check:

   reverse() reverses array order [OK]

Hint: Remember: reverse() flips the array 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 TypeScript?

easy

A. arr->reverse();

B. reverse(arr);

C. arr = reverse();

D. arr.reverse();

Solution

1. Step 1: Identify the method call on the array

   In TypeScript, reverse() is a method called directly on the array object using dot notation.

2. Step 2: Verify syntax

   arr.reverse(); is correct. reverse(arr); incorrectly treats reverse as a standalone function. arr = reverse(); misuses the method. arr->reverse(); uses invalid syntax.

3. Final Answer:

   arr.reverse(); -> Option D

4. Quick Check:

   Use dot notation: arr.reverse() [OK]

Hint: Use dot notation: array.reverse() [OK]

Common Mistakes:

• Calling reverse() as a standalone function
• Assigning reverse() without calling on array
• Using incorrect symbols like '->'

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

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

medium

A. [4, 3, 2, 1]

B. [1, 2, 3, 4]

C. [1, 4, 3, 2]

D. Error: reverse is not a function

Solution

1. Step 1: Understand the initial array

   The array starts as [1, 2, 3, 4].

2. Step 2: Apply the reverse() method

   Calling arr.reverse() reverses the array in place, changing it to [4, 3, 2, 1].

3. Final Answer:

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

4. Quick Check:

   reverse() flips array order [OK]

Hint: reverse() changes array order from end to start [OK]

Common Mistakes:

• Expecting original order after reverse()
• Confusing reverse() with sorting
• Thinking reverse() returns a new array

4. Identify the error in this TypeScript code that tries to reverse an array:

const numbers = [5, 6, 7];
const reversed = numbers.reverse;
console.log(reversed);

medium

A. reverse is not a valid method on arrays.

B. Missing parentheses to call reverse method.

C. reverse method should be called with an argument.

D. Array cannot be reversed using reverse method.

Solution

1. Step 1: Check how reverse is used

   The code assigns numbers.reverse without parentheses, so it assigns the function itself, not the reversed array.

2. Step 2: Correct usage of reverse()

   To reverse the array, the method must be called with parentheses: numbers.reverse().

3. Final Answer:

   Missing parentheses to call reverse method. -> Option B

4. Quick Check:

   Call reverse() with () to execute [OK]

Hint: Always use () to call methods like reverse() [OK]

Common Mistakes:

• Forgetting parentheses when calling methods
• Thinking reverse needs arguments
• Believing reverse is not a valid method

5. Given the array const data = [10, 20, 30, 40, 50];, which code snippet correctly reverses the array without modifying the original array?

hard

A. const reversed = data.reverse();

B. const reversed = data.sort().reverse();

C. const reversed = [...data].reverse();

D. const reversed = data.map().reverse();

Solution

1. Step 1: Understand the problem requirement

   We want to reverse the array but keep the original array unchanged.

2. Step 2: Analyze each option

   const reversed = data.reverse(); reverses the original array directly, modifying it.
   const reversed = [...data].reverse(); creates a shallow copy using spread [...data] and then reverses the copy, preserving the original.
   const reversed = data.sort().reverse(); sorts the original array first, changing order before reversing, and modifies original.
   const reversed = data.map().reverse(); uses map() incorrectly without a callback, causing error.

3. Final Answer:

   const reversed = [...data].reverse(); -> Option C

4. Quick Check:

   Copy then reverse to keep original safe [OK]

Hint: Copy array first with [...array] before reverse() [OK]

Common Mistakes:

• Using reverse() directly modifies original array
• Sorting before reversing changes order incorrectly
• Using map() without a callback causes error