Taken from LeetCode. This is a moderatley difficult problem which gets harder if you stay within the rule of O(1) extra space.

## The Question

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

``````Input: nums = [1,2,3,4,5,6,7], k = 3
Output: [5,6,7,1,2,3,4]
Explanation:
rotate 1 steps to the right: [7,1,2,3,4,5,6]
rotate 2 steps to the right: [6,7,1,2,3,4,5]
rotate 3 steps to the right: [5,6,7,1,2,3,4]
``````

Do not return anything, modify nums in-place instead.

## The Solution

The simplest, and completley valid, solution would be to use an additional array. By copying the values into a seperate array, you move the copied (and solved) array back to the original.

``````
def rotate(self, nums: List[int], k: int) -> None:

size = len(nums)
copy =  * size

for i, n in enumerate(nums):
copy[( i + k ) % size] = n

nums[:] = copy

``````

Note `nums[:] = copy`. This is intentional, and it will not work as `nums = copy` as that will change the reference to a copy of `nums` and not use the original array.

The time complexity would be O(n) and the space complexity would be O(n), since you need an additional array.

The solution I (and many other people) came up with is to reverse the array.   After reversing the list, reverse the first `k` numbers. Then rotate the last `n-k` numbers. The first reverse puts the numbers in a more-or-less correct order, then the subsequent reverses solve the remainder.

``````
def rotate(self, nums: List[int], k: int) -> None:

n = len(nums)
nums[:] = nums[n-(k % n):] + nums[:n-(k % n)]

``````

The runtime complexity will still be O(n). This is still not O(1) complexity, since splicing and reversing the array will require extra space.