How Do You Rotate an Array?

Rotating an array to the right by k positions means every element moves k places towards the end and the elements that fall off the end wrap around to the front. That is exactly a cyclic shift by k. The classic confusion is with a left rotation, where elements move towards the front instead, and with the in-place variant where no new array may be allocated.

Because the shift repeats every n positions, rotating by k is the same as rotating by k modulo n. Any k at least as large as the length reduces with a single modulo, and handling that explicitly is worth it because it is a common source of off-by-one errors, as is the case of k equal to zero.

There are three standard implementations. The first builds a new list by concatenating the last k elements with the first n minus k elements, which is O of n time and O of n extra space. The second uses the three reversal trick: reverse the whole array, reverse the first k elements, then reverse the rest, giving the same result in place with O of 1 extra space. The third rotates one step at a time, which is O of n times k and worth mentioning only to explain why it is the wrong choice.

The trade-off to name is space against clarity. The slicing version is one line and almost impossible to get wrong, which makes it the right choice for a small array or a quick script. The three reversal version is what you want when the array is large and the allocation matters, and it is the version interviewers like to see because it shows you can manipulate an array in place.

The three reversal trick produces a right rotation using only constant extra space. Reverse the whole array, then reverse the first k elements, then reverse the remaining n minus k elements.

def reverse(values, start, end):
    while start < end:
        values[start], values[end] = values[end], values[start]
        start += 1
        end -= 1

def rotate_right(values, k):
    n = len(values)
    if n == 0:
        return values
    k %= n
    reverse(values, 0, n - 1)
    reverse(values, 0, k - 1)
    reverse(values, k, n - 1)
    return values

data = [1, 2, 3, 4, 5, 6, 7]
print(rotate_right(data, 3))

The output is 5, 6, 7, 1, 2, 3, 4, which is the array rotated three places to the right. Working through the array seven, six, five, four, three, two, one: the full reversal puts the original last three elements first in reverse order, and reversing that first block of three gives five, six, seven. Reversing the rest then restores one, two, three, four in order.

The mechanism is that a rotation is a reversal of the whole thing, followed by two reversals that put each half back in order. Every reversal is a sequence of swaps, so the whole operation is a constant number of passes over the data with a constant number of variables.

The trade-off to name is readability. This version is longer and easier to get wrong than a single slicing expression, and the payoff is O of 1 extra space instead of O of n. There is one subtlety to handle carefully: if k is zero, the second reversal covers an empty range, and the helper must not try to swap an element with itself out of bounds. Taking k modulo n first also guarantees that the two reversal ranges always cover the array without overlapping, which is what keeps the trick correct.

Slicing expresses the rotation directly: take the last k elements and put them in front of the remaining ones. Because Python slicing handles negative bounds gracefully, the tail of the array comes for free.

data = [1, 2, 3, 4, 5]
k = 2
rotated = data[-k:] + data[:-k]
print(rotated)
print(data)

The outputs are 4, 5, 1, 2, 3 and the original list 1, 2, 3, 4, 5. The original is untouched, because slicing produces new lists rather than views, so the rotation is a copy rather than a mutation.

The cost is space. The expression allocates two intermediate slices and then a third list for the concatenation, so it uses O of n extra memory and touches each element a constant number of times. That makes it O of n time and O of n space, compared with the O of n time and O of 1 space of the reversal trick.

The trade-off to name is that for anything but a very large array, the one-liner wins on clarity and nobody will ever notice the allocation. For a million-element array rotated in a tight loop, the copies become the dominant cost and the in-place version is the right choice. There is also a subtlety worth knowing: when k is zero, the expression data minus zero gives the whole list and data up to minus zero gives an empty list, so the result is still correct, but writing the modulo explicitly makes the intent clearer and protects against k larger than the array length.