I have a working solution for this problem that was accepted in LeetCode:

"Given an array, rotate the array to the right by k steps, where k is non-negative."

function rotate(nums, k) {

  for (let i = 1; i <= k; i += 1) {

    const poppedNum = nums.pop();

    nums.unshift(poppedNum);

  }



  return nums;

}



// rotate([1, 2, 3, 4, 5, 6, 7], 3) -> [5, 6, 7, 1, 2, 3, 4]

Questions:

• Would the time complexity be O(k) and space complexity be O(1)?




• Is there a better way to solve this? The question asked to rotate the elements in-place if possible, but I am not sure how to accomplish this at the moment.

Review

Not bad, but there is room for a few improvements to avoid some possible problematic input arguments.

Style

Some points on your code.

• The names nums and k could be better, maybe array and rotateBy
  


• Try to avoid one use variables unless it makes the lines using them to long. Thus you can pop and unshift in one line nums.unshift(nums.pop());
  


• Idiomatic javascript uses zero based loop counters rather than starting at 1. Thus the loop would be for (let i = 0; i < k; i++) {
  

Complexity

Your complexity is O(n) and storage O(1) where n is the number of rotations, the range of n is > 0

However consider the next examples

rotate([1,2,3,4,5,6,7,8,9], 18); // Will rotate 18 times same as rotate 0

rotate([1,2,3,4,5,6,7,8,9], 8); // Will rotate 8 times same as rotate left 1

rotate([1], 8e9); // Will spend a lot of time not changing anything

Your function will do too much work if the rotations are outside the expected ranges, the rotation can be done in reverse in less steps, or rotating has no effect.

You can limit the complexity to O(n) where n <= array.length / 2

Rewrite

This is a slight improvement on your function to ensure you don't rotate more than needed.

function rotate(array, rotateBy) {

    rotateBy %= array.length;

    if (rotateBy < array.length - rotateBy) {

        while (rotateBy--) { array.unshift(array.pop()) }

    } else {

        rotateBy = array.length - rotateBy;

        while (rotateBy--) { array.push(array.shift()) }

    }

    return array;

}

You could also use Array.splice

 array.unshift(...array.splice(-rotateBy,rotateBy));

However under the hood the complexity would be a little greater O(2n) (which is still O(n)) as splice steps over each item to remove and add to a new array. Then ... steps over them again to unshift each item to the array.

The storage would also increase as the spliced array is held in memory until the code has finished unshifting them making storage O(n)

If the array contained all the same values the rotation would have no effect thus all rotation could be done in O(1). However there is no way to know this without checking each item in turn.

The time complexity really depends on the unshift time complexity. ECMA does not specify it, but I would expect that it is not constant. I would not be surprised if it is actually linear in the size of the array. If so, the complexity of rotate would be $O(nk)$.

In fact, I tested the performance of your code by timing your rotate by 1, for arrays of size from 100000 to 100000000, doubling the size every time. The results (in milliseconds) are

1, 3, 8, 14, 29, 33, 69, 229, 447, 926

I did few runs, the exact numbers were different, but consistent. You can see that as size doubles the run time (at lest) doubles as well.

And again, it was rotation by 1. Rotation by k will take proportionally longer.

There are few classic algorithms which perform the rotation in true $O(n)$ complexity, that is their execution time does not depend on k. One is extremely simple to code, but takes effort to comprehend. In pseudocode:

    reverse(0, k)

    reverse(k, n)

    reverse(0, n)

Notice that each element is moved twice. This is suboptimal. Another algorithm moves each element exactly once - right into the place where it belongs. I don't want to spoil the fun of discovering it. Try to figure it out (hint: it needs to compute gcd(n, k)).

That said, the leetcode problem only asks to print the rotated array. I would seriously consider to not actually perform rotation, but

    print values from n-k to n

    print values from 0 to n-k

It feels like cheating, but in fact it is valid, and sometimes very useful technique.