Right Rotate an array by k elements – Tech Interview Dot Org

An array of elements is given arr
arr is of length n
Right rotate array by k elements
Time complexity O(n) and space complexity O(1)

Sample Input:
arr = {1,2 ,3,4,5}
n = 5
k = 2
Output :
arr = {4,5,1,2,3}

💡Strategies for Solving This Problem

The Rotation Trick

Got this at Microsoft. It seems simple but most people do it the hard way with extra space. The elegant solution uses reversals - it's one of those "once you see it, you can't unsee it" tricks.

Naive Approach

Create a new array, copy elements to rotated positions. Works but uses O(n) extra space. Interviewer will ask "Can you do it in-place?"

The Reversal Trick

To rotate right by k positions:

Reverse entire array
Reverse first k elements
Reverse remaining n-k elements

Example: [1,2,3,4,5] rotate right by 2

Reverse all: [5,4,3,2,1]
Reverse first 2: [4,5,3,2,1]
Reverse last 3: [4,5,1,2,3] ✓

O(n) time, O(1) space. This is what they want.

Why It Works

Think about it: rotation moves the last k elements to the front. By reversing, we're essentially moving them but in reverse order. Then we fix each part's order.

My Microsoft interviewer said "This is a classic trick. If you didn't know it before, you do now."

Edge Cases

k > n: Use k % n (rotating n times = original array)
k = 0 or k = n: No rotation needed
Empty array: Return as-is

✅Solution

Solution: Three Reversals

function rotate(nums, k) {
    const n = nums.length;
    if (n === 0) return;

    // Handle k > n
    k = k % n;
    if (k === 0) return;

    // Helper to reverse portion of array
    function reverse(start, end) {
        while (start < end) {
            [nums[start], nums[end]] = [nums[end], nums[start]];
            start++;
            end--;
        }
    }

    // Step 1: Reverse entire array
    reverse(0, n - 1);

    // Step 2: Reverse first k elements
    reverse(0, k - 1);

    // Step 3: Reverse remaining elements
    reverse(k, n - 1);
}

// Tests
let arr1 = [1, 2, 3, 4, 5];
rotate(arr1, 2);
console.log(arr1);  // [4, 5, 1, 2, 3]

let arr2 = [1, 2, 3];
rotate(arr2, 4);  // k > n, becomes k=1
console.log(arr2);  // [3, 1, 2]

let arr3 = [1];
rotate(arr3, 5);
console.log(arr3);  // [1] (single element)

Step-by-Step Example

Rotate [1, 2, 3, 4, 5, 6, 7] right by 3:

Original:        [1, 2, 3, 4, 5, 6, 7]

Step 1 - Reverse all:
                 [7, 6, 5, 4, 3, 2, 1]

Step 2 - Reverse first 3:
                 [5, 6, 7, 4, 3, 2, 1]

Step 3 - Reverse last 4:
                 [5, 6, 7, 1, 2, 3, 4]

Result: Last 3 elements moved to front ✓

Alternative: Using Extra Space

function rotateWithSpace(nums, k) {
    const n = nums.length;
    k = k % n;

    // Create new array with rotated elements
    const result = new Array(n);

    for (let i = 0; i < n; i++) {
        result[(i + k) % n] = nums[i];
    }

    // Copy back to original
    for (let i = 0; i < n; i++) {
        nums[i] = result[i];
    }
}

This works but uses O(n) space. The reversal method is better.

Rotate Left Instead?

To rotate LEFT by k, just rotate RIGHT by (n - k):

function rotateLeft(nums, k) {
    rotate(nums, nums.length - k);
}

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

Complexity Analysis

Time: O(n) - Each element is reversed at most twice
Space: O(1) - Only swap variables, in-place modification

Compare to extra space solution: O(n) time, O(n) space

Why This Pattern Matters

The "reverse multiple times" pattern shows up in other problems:

Reverse words in a sentence
Rotate matrix
Cyclic array operations

My interviewer asked "Where else could you use this technique?" - be ready to discuss the pattern, not just memorize this solution.