We need to shift every element in the array k positions to the right. Elements that "fall off" the right end wrap around to the beginning.

An important detail: k can be larger than the array length. Rotating an array of length n by n steps brings it back to the original, so we only care about k % n effective rotations. If k = 10 and n = 7, that's the same as rotating by 3.

The problem also asks us to modify the array in-place, which rules out creating and returning a new array. Using extra space as an intermediate step and copying back is still allowed, and we cover that as one approach.

Key Constraints:

Intuition

We can do exactly what the problem describes: rotate the array by one position, then repeat that k times. A single right rotation by one moves every element one slot to the right, and the last element wraps around to the front.

To perform one rotation, save the last element, shift every other element one position to the right, then place the saved element at index 0. After k such rotations, the array is rotated by k.

Algorithm

Example Walkthrough

Code

This repeats a lot of work. Every element moves k times, one position per rotation, even though its final destination is fixed at (i + k) % n from the start. Computing that destination once and writing the element there directly removes the intermediate shifts entirely.

Intuition

When we rotate right by k, the element at index i ends up at index (i + k) % n. The modulo handles the wraparound for elements that pass the right end. With that formula we can write each element straight to its final slot in a separate array, then copy the result back into nums.

Algorithm

Example Walkthrough

Code

This runs in O(n) time, but it uses a second array of size n. The mapping (i + k) % n is correct, yet the full copy is not strictly necessary. The next two approaches achieve the same rearrangement in O(1) extra space by working within the original array.

Intuition

The extra-array approach already knows the final position of every element: the element at index i belongs at (i + k) % n. The only reason it needed a second array was to avoid overwriting a value before it was moved.

We can avoid that conflict without a second array. Pick a starting index, save its value, then move it to its target. Doing so overwrites whatever was at the target, so save that value first and move it next. Following this chain of "evict, then place" steps traces a cycle that eventually returns to the starting index, with every element along the way landing in its final slot.

One cycle does not always cover the whole array. The chain returns to where it started after visiting n / gcd(n, k) elements, so there are gcd(n, k) separate cycles. To handle all of them, advance the start index by one each time a cycle closes and keep going until every element has been placed. A single counter of placed elements tells us when to stop.

Algorithm

Example Walkthrough

For this input gcd(7, 3) is 1, so a single cycle touches all seven elements. When n and k share a factor, for example n=4 and k=2, gcd is 2 and the loop runs two cycles starting at index 0 and index 1, which is why the count check and the advancing start index are both needed.

Code

The cyclic approach matches the optimal time and space bounds, but tracking cycles and the eviction chain is harder to get right than three plain reversals. The next approach reaches the same O(n) time and O(1) space with simpler code.

Intuition

A rotation splits the array into two blocks and swaps their order. With nums = [1, 2, 3, 4, 5, 6, 7] and k = 3, the result [5, 6, 7, 1, 2, 3, 4] is the last 3 elements [5, 6, 7] followed by the first 4 elements [1, 2, 3, 4]. The two blocks keep their internal order; only the blocks switch places.

Reversing the whole array gets both blocks into the front-vs-back arrangement we want, but with each block's elements running backward. Reversing [1, 2, 3, 4, 5, 6, 7] gives [7, 6, 5, 4, 3, 2, 1]. The first 3 slots now hold [7, 6, 5], which are the correct front-block values in reverse, and the last 4 slots hold [4, 3, 2, 1], the correct back-block values in reverse.

Reversing each block in place fixes the internal order. Reverse the first 3: [5, 6, 7]. Reverse the last 4: [1, 2, 3, 4]. The array is now [5, 6, 7, 1, 2, 3, 4], the rotated answer, produced with three reversals and no extra array.

Why the block boundary lands at index k: after a right rotation by k, the k elements that came from the tail occupy the first k slots, so the first reversal block is [0, k-1] and the second is [k, n-1].

Algorithm

Example Walkthrough

Code