Rotating right by k moves the last k items to the front. Call the first n - k items block A and the last k items block B. The array is A B, and the rotated array is B A.

Reversing a whole sequence reads it from the end. So reverse(A B) gives the items of B first, in reversed order, then the items of A, in reversed order. Write this as B^R A^R. The blocks are now in the right places, but each block is mirrored.

Two more reversals fix the mirror. reverse(0, k - 1) turns B^R back into B. reverse(k, n - 1) turns A^R back into A. The array is B A.

Trace nums = [1, 2, 3, 4, 5, 6, 7] with k = 10. After k %= n, k = 3, so A = [1, 2, 3, 4] and B = [5, 6, 7]. reverse(0, 6) gives [7, 6, 5, 4, 3, 2, 1]. reverse(0, 2) gives [5, 6, 7, 4, 3, 2, 1]. reverse(3, 6) gives [5, 6, 7, 1, 2, 3, 4]. Rotate Array (LC 189) gives the same answer for k = 3, the value in its first example.

Each reverse is the two-pointer swap from the Squeeze Ends card: lo and hi move inward and swap until they meet. This card adds only the choice of the three ranges.

Rotating by n moves every item all the way around, so the array is the same as before. Rotating by k and rotating by k % n give the same array.

Without k %= n, a k larger than n breaks the code. For n = 7 and k = 10, reverse(0, k - 1) is reverse(0, 9), and nums[9] raises an IndexError.

The check if n == 0: return comes before k %= n. In Python, k %= 0 raises a ZeroDivisionError.

When k % n is 0, reverse(0, -1) has lo >= hi at once and does nothing. The other two reversals then undo each other, because the second reverses the whole array again. The array stays the same.

The whole array must be reversed first. If the two parts are reversed first and the whole array last, the result is a rotation to the left by k. For nums = [1, 2, 3, 4, 5, 6, 7] and k = 3, the parts give [3, 2, 1, 7, 6, 5, 4], and the whole reversal gives [4, 5, 6, 7, 1, 2, 3]. This is the correct order for a left rotation. A right rotation by k is the same as a left rotation by n - k.

The function must change the list that the caller passed. The line nums = nums[-k:] + nums[:-k] builds a new list and points the local name nums at it. The caller's list does not change, and the new list also uses O(N) extra space. The swaps nums[lo], nums[hi] = nums[hi], nums[lo] change the original list.

Shift 2D Grid (LC 1260) moves the last value of each row to the start of the next row. Read the grid as one list, row by row. Index i of that list is the cell (i // cols, i % cols). Rotate the list, then write it back. Rotating each row on its own is wrong.

The three reversals swap about n / 2 + k / 2 + (n - k) / 2 pairs, which is about n swaps. So the time is O(N) and the space is O(1). For the board, the reversals use 3, 1 and 2 swaps, which is 6 swaps for 7 items.

A copy into a new list is O(N) time and O(N) space. Moving each item to its final place, one cycle at a time, is O(N) time and O(1) space, but it needs the gcd of n and k to count the cycles. The three reversals are shorter to write.

Reverse Words in a String (LC 151) uses the same idea in another shape: reverse the whole text, then reverse each word. The in-place version is Reverse Words in a String II (LC 186).

Rotate List (LC 61) rotates a linked list. A linked list has no indices to swap from both ends, so find the new tail and change the links instead. Rotate Image (LC 48) turns a square grid by 90 degrees. Rows become columns, which no shift of one flat list can do.