Array Rotation Techniques in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2

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

DSA Typescript

function leftRotate(arr: number[], d: number): number[] {
  const n = arr.length;
  const rotated = arr.slice(d % n).concat(arr.slice(0, d % n));
  return rotated;
}

const arr = [10, 20, 30, 40, 50];
const result = leftRotate(arr, 2);
console.log(result);

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

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

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

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

💡 Hint

Think about moving the first two elements to the end of the array.

Left rotation by 2 means the first two elements (10, 20) move to the end, so the array becomes [30, 40, 50, 10, 20].

❓ Predict Output

intermediate

Output of Right Rotation by 3

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

DSA Typescript

function rightRotate(arr: number[], d: number): number[] {
  const n = arr.length;
  const rotated = arr.slice(n - (d % n)).concat(arr.slice(0, n - (d % n)));
  return rotated;
}

const arr = [1, 2, 3, 4, 5, 6];
const result = rightRotate(arr, 3);
console.log(result);

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

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

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

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

💡 Hint

Right rotation by 3 means last 3 elements move to the front.

Right rotation by 3 moves elements 4,5,6 to the front, resulting in [4,5,6,1,2,3].

🔧 Debug

advanced

Identify the Error in Rotation Code

The following TypeScript function is intended to rotate an array to the left by d positions. What error will it cause when run?

DSA Typescript

function rotateLeft(arr: number[], d: number): number[] {
  const n = arr.length;
  return arr.slice(d).concat(arr.slice(0, d));
}

const result = rotateLeft([], 3);
console.log(result);

A RangeError: Invalid array length

B TypeError: Cannot read property 'slice' of undefined

C []

D [] (empty array, no error)

💡 Hint

What happens when you slice an empty array?

Slicing an empty array returns an empty array, so concatenating two empty arrays results in an empty array with no error.

🧠 Conceptual

advanced

Minimum Rotations to Restore Original Array

Given an array of length 7, what is the minimum number of left rotations needed to restore the array to its original order?

A 14

B 7

C 1

D 0

💡 Hint

Think about how many rotations bring the array back to start.

Rotating an array by its length (7) returns it to the original order.

🚀 Application

expert

Result of Multiple Rotations

Starting with array [1, 2, 3, 4, 5], you perform a left rotation by 2, then a right rotation by 3. What is the final array?

DSA Typescript

function leftRotate(arr: number[], d: number): number[] {
  const n = arr.length;
  return arr.slice(d % n).concat(arr.slice(0, d % n));
}

function rightRotate(arr: number[], d: number): number[] {
  const n = arr.length;
  return arr.slice(n - (d % n)).concat(arr.slice(0, n - (d % n)));
}

let arr = [1, 2, 3, 4, 5];
arr = leftRotate(arr, 2);
arr = rightRotate(arr, 3);
console.log(arr);

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

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

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

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

💡 Hint

Perform each rotation step by step and track the array.

Left rotation by 2: [3,4,5,1,2]; then right rotate by 3: [5,1,2,3,4].

Practice

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

easy

A. [4, 1, 2, 3]

B. [2, 3, 4, 1]

C. [1, 2, 3, 4]

D. [3, 4, 1, 2]

Solution

1. Step 1: Understand right rotation

   Right rotation by 1 means the last element moves to the front, shifting others right.

2. Step 2: Apply to example array

   Last element 4 moves to front, rest shift right: [4, 1, 2, 3].

3. Final Answer:

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

4. Quick Check:

   Right rotate by 1 = last element front [OK]

Hint: Right rotate by 1 means last element moves front [OK]

Common Mistakes:

• Confusing right rotation with left rotation
• Not moving the last element to front
• Shifting elements incorrectly

2. Which of the following TypeScript code snippets correctly rotates an array arr to the left by 1 position?

easy

A. arr.push(arr.shift()!)

B. arr.unshift(arr.pop()!)

C. arr.pop(); arr.unshift(arr.pop()!)

D. arr.shift(); arr.push(arr.shift()!)

Solution

1. Step 1: Understand left rotation by 1

   Left rotation by 1 means first element moves to the end.

2. Step 2: Check code snippets

   arr.push(arr.shift()!) uses arr.shift() to remove first element and arr.push() to add it at end, correct for left rotation.

3. Final Answer:

   arr.push(arr.shift()!) -> Option A

4. Quick Check:

   Left rotate = shift then push [OK]

Hint: Left rotate by 1 = remove first, add to end [OK]

Common Mistakes:

• Using pop instead of shift for left rotation
• Using unshift with pop for left rotation
• Calling shift or pop twice incorrectly

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

const arr = [10, 20, 30, 40, 50];
const k = 2;
const rotated = arr.slice(-k).concat(arr.slice(0, arr.length - k));
console.log(rotated);

medium

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

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

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

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

Solution

1. Step 1: Understand slicing for rotation

   arr.slice(-k) takes last 2 elements: [40, 50]. arr.slice(0, arr.length - k) takes first 3 elements: [10, 20, 30].

2. Step 2: Concatenate slices

   Concatenating gives [40, 50, 10, 20, 30], which is right rotation by 2.

3. Final Answer:

   [40, 50, 10, 20, 30] -> Option B

4. Quick Check:

   Right rotate by 2 = last 2 front [OK]

Hint: Right rotate by k = last k elements + rest [OK]

Common Mistakes:

• Using slice with wrong indices
• Confusing left and right rotation
• Not concatenating slices in correct order

4. Find the error in this TypeScript function that rotates an array to the left by k positions:

function rotateLeft(arr: number[], k: number): number[] {
  for (let i = 0; i < k; i++) {
    arr.push(arr.shift());
  }
  return arr;
}

medium

A. arr.push() should be arr.unshift()

B. Loop should run from i = 1 to k

C. arr.shift() can return undefined, causing push(undefined)

D. Function should return void, not number[]

Solution

1. Step 1: Check arr.shift() return type

   arr.shift() returns element or undefined if array empty. Here, no check for undefined.

2. Step 2: Effect on arr.push()

   If arr.shift() returns undefined, arr.push(undefined) adds undefined to array, causing incorrect result or runtime issues.

3. Final Answer:

   arr.shift() can return undefined, causing push(undefined) -> Option C

4. Quick Check:

   shift may be undefined, must check [OK]

Hint: Check shift() return before push to avoid undefined [OK]

Common Mistakes:

• Ignoring undefined from shift()
• Wrong loop range assumptions
• Confusing push and unshift methods

5. Given an array arr of length n, how can you rotate it to the left by k positions efficiently without using extra space? Choose the correct approach.

hard

A. Use a temporary array to store first k elements, then shift rest left, then copy temp at end

B. Sort the array and then rotate by k positions

C. Rotate one by one k times using shift and push

D. Reverse first k elements, reverse last n-k elements, then reverse whole array

Solution

1. Step 1: Understand in-place rotation using reversal

   Reversing parts of array and then whole array rotates left by k without extra space.

2. Step 2: Apply reversal steps

   Reverse first k elements, reverse last n-k elements, then reverse entire array to get rotated array.

3. Final Answer:

   Reverse first k, reverse last n-k, reverse whole array -> Option D

4. Quick Check:

   Reversal method = in-place left rotate [OK]

Hint: Use triple reversal for in-place left rotation [OK]

Common Mistakes:

• Using extra array when not needed
• Rotating one by one causing O(n*k) time
• Sorting array unrelated to rotation