LeetCode 189 - Rotate Array 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 &lt;= k; i += 1) {
    const poppedNum = nums.pop();
    nums.unshift(poppedNum);
  }

  return nums;
}

// rotate([1, 2, 3, 4, 5, 6, 7], 3) -&gt; [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 &lt; k; i++) {

Complexity
Your complexity is \$O(n)\$ and storage \$O(1)\$ where \$n\$ is the number of rotations, the range \$n&gt;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(k)\$ where \$0&lt;k&lt;=n/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 &lt; array.length - rotateBy) {
        while (rotateBy--) { array.unshift(array.pop()) }
    } else {
        rotateBy = array.length - rotateBy;
        while (rotateBy--) { array.push(array.shift()) }
    }
    return array;
}

Update
As vnp's answer points out the complexity of Array.unshift and Array.shift is not as simple as \$O(1)\$ and will depend on the array type. We can assume the best case for this problem, sparse array (effectively a hash table) and thus will grow/shrink down at \$O(1)\$
In that case the function above has a mean complexity of \$O(log(n))\$ of all possible values of \$k\$
Note that if the cost of grow/shrink operations is \$O(n)\$ (dense array) this will add \$n\$ operations for each \$k\$ making the above \$O(kn)\$ with \$0&lt;=k&lt;(n/2)\$ Expressed in terms of \$n\$ or \$k\$ only it remains \$O(log(n))\$  or \$O(k)\$

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.