Array Rotation Techniques in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Rotation by 2

What is the output of the following JavaScript code that rotates an array to the left by 2 positions?

DSA Javascript

const arr = [10, 20, 30, 40, 50];
const rotateLeft = (array, k) => {
  const n = array.length;
  k = k % n;
  return array.slice(k).concat(array.slice(0, k));
};
console.log(rotateLeft(arr, 2));

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 this JavaScript code that rotates an array to the right by 3 positions?

DSA Javascript

const arr = [1, 2, 3, 4, 5, 6];
const rotateRight = (array, k) => {
  const n = array.length;
  k = k % n;
  return array.slice(n - k).concat(array.slice(0, n - k));
};
console.log(rotateRight(arr, 3));

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

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

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

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

💡 Hint

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

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

🧠 Conceptual

advanced

Time Complexity of Rotation Using Slicing

What is the time complexity of rotating an array of size n by k positions using the slicing and concatenation method shown in previous examples?

A O(n*k)

B O(k)

C O(1)

D O(n)

💡 Hint

Consider how many elements are copied during slicing and concatenation.

Slicing and concatenation each copy parts of the array, so total operations scale linearly with n.

❓ Predict Output

advanced

Output of In-Place Left Rotation by 1

What is the output of this JavaScript code that rotates an array to the left by 1 position in-place?

DSA Javascript

const arr = [7, 8, 9, 10];
const rotateLeftInPlace = (array) => {
  const first = array.shift();
  array.push(first);
  return array;
};
console.log(rotateLeftInPlace(arr));

A [8, 9, 10, 7]

B [10, 7, 8, 9]

C [7, 8, 9, 10]

D [9, 10, 7, 8]

💡 Hint

The first element is removed and added to the end.

shift() removes 7, push() adds it to the end, resulting in [8, 9, 10, 7].

❓ Predict Output

expert

Output After Multiple Rotations

Given the code below, what is the final state of the array after performing the rotations?

DSA Javascript

let arr = [1, 2, 3, 4, 5];
const rotateLeft = (array, k) => {
  const n = array.length;
  k = k % n;
  return array.slice(k).concat(array.slice(0, k));
};
arr = rotateLeft(arr, 2);
arr = rotateLeft(arr, 3);
console.log(arr);

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

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

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

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

💡 Hint

Think about the effect of rotating left by 2, then by 3 on the same array.

Rotating left by 2 then by 3 is equivalent to rotating left by (2+3)=5, which is a full rotation returning the array to original.

Practice

1. What does rotating an array to the right by 1 position mean?
arr = [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 by 1

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

2. Step 2: Apply to given 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: Last element moves front on right rotation by 1 [OK]

Common Mistakes:

• Confusing left and right rotation
• Shifting elements left instead of right
• Not moving last element to front

2. Which of the following is the correct JavaScript syntax to rotate an array arr to the left by 1 position?

easy

A. arr.unshift(arr.pop())

B. arr.push(arr.shift())

C. arr.pop(arr.unshift())

D. arr.shift(arr.push())

Solution

1. Step 1: Understand left rotation by 1

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

2. Step 2: Match syntax to operation

   arr.shift() removes first element, arr.push() adds it to end. So arr.push(arr.shift()) rotates left by 1.

3. Final Answer:

   arr.push(arr.shift()) -> Option B

4. Quick Check:

   Left rotate = shift then push [OK]

Hint: Left rotate = shift first, then push it back [OK]

Common Mistakes:

• Using pop instead of shift for left rotation
• Using unshift incorrectly
• Mixing push and pop order

3. What is the output of the following 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. [40, 50, 10, 20, 30]

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

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

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

Solution

1. Step 1: Understand slicing for right rotation by k=2

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

2. Step 2: Concatenate slices

   Concatenate [40, 50] + [10, 20, 30] = [40, 50, 10, 20, 30].

3. Final Answer:

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

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(0, k) instead of slice(-k)
• Concatenating in wrong order
• Confusing left and right rotation

4. Find the error in this code that tries to rotate an array arr left by k positions:

function rotateLeft(arr, k) {
  for(let i = 0; i < k; i++) {
    arr.unshift(arr.shift());
  }
  return arr;
}

medium

A. Using unshift instead of push inside loop

B. Loop should run from i = 1 to k

C. No error, code works correctly

D. shift() removes last element, should use pop()

Solution

1. Step 1: Analyze loop operation

   Inside loop, arr.shift() removes first element correctly for left rotation.

2. Step 2: Check insertion method

   arr.unshift() adds element to front, which reverses the shift effect. It should be arr.push() to add at end.

3. Final Answer:

   No error, code works correctly -> Option C

4. Quick Check:

   Code rotates left by k positions correctly [OK]

Hint: Left rotate = shift then push, not unshift [OK]

Common Mistakes:

• Using unshift instead of push
• Confusing shift and pop
• Incorrect loop range

5. Given an array arr = [1, 2, 3, 4, 5], how can you rotate it left by k = 7 positions efficiently without extra space?

hard

A. Rotate left by k positions using nested loops

B. Rotate left by k positions directly using slice and concat

C. Rotate right by k positions using pop and unshift

D. Rotate left by k % arr.length = 2 positions using reversal algorithm

Solution

1. Step 1: Calculate effective rotation

   Since k=7 and arr.length=5, effective rotation is k % 5 = 2.

2. Step 2: Use reversal algorithm for in-place rotation

   Reverse first 2 elements, reverse last 3 elements, then reverse whole array to rotate left by 2 efficiently without extra space.

3. Final Answer:

   Rotate left by k % arr.length = 2 positions using reversal algorithm -> Option D

4. Quick Check:

   Use k mod length and reversal for efficient rotation [OK]

Hint: Use k mod array length and reversal for efficient rotation [OK]

Common Mistakes:

• Rotating by k without modulo causes extra rotations
• Using slice creates extra space
• Using nested loops is inefficient