Rotate an Array by k Positions in Python

“Learning how to rotate array by k positions in Python is a milestone for every programmer. If you’ve been solving array problems, you’ve definitely come across this challenge.It’s one of those questions that looks deceptively simple — but if you don’t know the trick, you’ll waste time in an interview.

So what exactly is array rotation in Python? Simple — imagine your array is a circular track. Rotating it means moving every element by k steps either to the left or to the right. The elements that fall off one end come back from the other.

For example, think of a music playlist. When you skip 2 songs forward, the first two songs move to the end of the queue. That’s array rotation in real life.

This problem is asked in companies like Amazon, Infosys, TCS, Wipro, and Google because it tests your understanding of arrays, modulo arithmetic, and in-place algorithms — all fundamentals for any software engineer.

02: Problem Statement

Given an array arr of n elements and an integer k, rotate the array by k positions.

• Left Rotation: Elements shift towards the left. The first k elements move to the end.
• Right Rotation: Elements shift towards the right. The last k elements move to the beginning.

Example 1 — Left Rotation

Input  : arr = [1, 2, 3, 4, 5],  k = 2
Left   : [3, 4, 5, 1, 2]   ← elements shifted 2 places to the left

Example 2 — Right Rotation

Right  : [4, 5, 1, 2, 3]   ← elements shifted 2 places to the right

Input / Output Format

• Line 1: Integer n — size of the array
• Line 2: n space-separated integers
• Line 3: Integer k — number of positions to rotate
• Output: The rotated array printed space-separated

Constraints

• 1 ≤ n ≤ 10⁵
• 0 ≤ k ≤ 10⁹
• −10⁹ ≤ arr[i] ≤ 10⁹

03: Why This Problem Is Important

Array rotation isn’t just a textbook exercise — it shows up in real systems all the time:

• 🎵 Music Playlist: Cycling through songs in a loop
• 🖥️ CPU Round-Robin Scheduling: Each process gets a turn in a rotating queue
• 📷 Image Processing: Shifting pixel rows/columns for effects
• 💾 Circular Buffers: Used in networking and OS memory management
• 🎮 Game Turns: Rotating players in a multiplayer game
• 📡 Signal Processing: Shifting sample windows in streaming data

Understanding this problem deeply helps you tackle harder problems like search in rotated sorted array, next permutation, and sliding window algorithms.

04: Naive Approach — One Step at a Time

The simplest idea: rotate by 1 position, k times. For a left rotation by 1, pop the first element and append it to the end. Repeat this k times.

def naive_left_rotate(arr, k):
    n = len(arr)
    k = k % n
    for _ in range(k):
        first = arr[0]          # store first element
        arr = arr[1:] + [first] # shift left by 1
    return arr

This works, but it’s slow. Every single rotation is O(n), and you do it k times — giving O(n × k) total time. If n = 100,000 and k = 50,000, that’s 5 billion operations. Not interview-friendly at all.

05: Optimal Approach 1 — Python Slicing Method

Rotate Array by k Positions in Python Using Slicing
This is the most Pythonic and readable solution. The idea is simple: split the array at index k and swap the two parts.

• Left rotate: arr[k:] + arr[:k]
• Right rotate: arr[n-k:] + arr[:n-k]

arr = [1, 2, 3, 4, 5]
k = 2
n = len(arr)
k = k % n   # handle k > n

left_rotated  = arr[k:] + arr[:k]   # [3, 4, 5, 1, 2]
right_rotated = arr[n-k:] + arr[:n-k] # [4, 5, 1, 2, 3]

Clean, readable, and runs in O(n) time. The only trade-off is that it uses O(n) extra space for the new list. For most practical use cases and interviews, this is perfectly acceptable.

06: Optimal Approach 2 — Reversal Algorithm

This is the gold standard for interviews. It rotates in-place with O(1) extra space. Here’s the trick for left rotation by k:

1. Reverse the first k elements
2. Reverse the remaining n-k elements
3. Reverse the entire array

For arr = [1,2,3,4,5], k = 2:

Original      : [1, 2, 3, 4, 5]
Step 1 (rev 0..k-1) : [2, 1, 3, 4, 5]
Step 2 (rev k..n-1) : [2, 1, 5, 4, 3]
Step 3 (rev all)    : [3, 4, 5, 1, 2]  ✓ Left rotated!

def reverse(arr, left, right):
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left  += 1
        right -= 1

def left_rotate_reversal(arr, k):
    n = len(arr)
    k = k % n
    reverse(arr, 0, k - 1)   # reverse first k elements
    reverse(arr, k, n - 1)   # reverse remaining elements
    reverse(arr, 0, n - 1)   # reverse entire array
    return arr

This uses O(n) time, O(1) space — the best you can do for this problem.

07: Flowchart

08: Pseudocode

FUNCTION rotate_array(arr, k, direction):
    n ← length(arr)
    IF n == 0 THEN RETURN arr

    k ← k MOD n
    IF k == 0 THEN RETURN arr

    IF direction == "left" THEN
        RETURN arr[k..n-1] + arr[0..k-1]
    ELSE IF direction == "right" THEN
        RETURN arr[n-k..n-1] + arr[0..n-k-1]

END FUNCTION

09: Complete Python Program

Complete Program to Rotate Array by k Positions in Python

def left_rotate(arr, k):
    """Left rotate array by k positions using slicing."""
    n = len(arr)
    if n == 0: return arr
    k = k % n              # handle k > n
    return arr[k:] + arr[:k]

def right_rotate(arr, k):
    """Right rotate array by k positions using slicing."""
    n = len(arr)
    if n == 0: return arr
    k = k % n              # handle k > n
    return arr[n - k:] + arr[:n - k]

def left_rotate_inplace(arr, k):
    """Left rotate using reversal algorithm — O(1) space."""
    n = len(arr)
    if n == 0: return arr
    k = k % n

    def reverse(a, l, r):
        while l < r:
            a[l], a[r] = a[r], a[l]
            l += 1; r -= 1

    reverse(arr, 0, k - 1)
    reverse(arr, k, n - 1)
    reverse(arr, 0, n - 1)
    return arr


n   = int(input("Enter array size: "))
arr = list(map(int, input("Enter elements: ").split()))
k   = int(input("Enter k: "))

print("Left Rotate  :", left_rotate(arr[:], k))
print("Right Rotate :", right_rotate(arr[:], k))
print("Left (In-place):", left_rotate_inplace(arr[:], k))

Sample Output

Enter array size: 5
Enter elements: 1 2 3 4 5
Enter k: 2

Left Rotate   : [3, 4, 5, 1, 2]
Right Rotate  : [4, 5, 1, 2, 3]
Left (In-place): [3, 4, 5, 1, 2]

10: Dry Run — Step by Step

Let’s trace arr = [1, 2, 3, 4, 5], k = 2 manually.

Left Rotation (Slicing)

Right Rotation (Slicing)

Left Rotation (Reversal Algorithm)

11: Time & Space Complexity

The reversal algorithm is best in interviews because it gives O(n) time AND O(1) space — modifying the array in place with no extra memory. The slicing method, while clean, creates a new list in memory.

12: Test Cases & Edge Cases

13: Common Interview Questions

14: Mistakes Beginners Make

• ❌ Forgetting k % n — causes wrong output when k > n
• ❌ Wrong slicing index for right rotation — use arr[n-k:], not arr[-k:] (they work the same but -k can confuse you)
• ❌ Confusing left and right — always test with a small example before coding
• ❌ Not handling empty array — will crash with ZeroDivisionError on k % n
• ❌ Mutating original array accidentally — use arr[:] to pass a copy
• ❌ Naive approach in interview — O(n×k) will fail large test cases

15: FAQ

✓Conclusion

You’ve now learned everything about rotate an array by k positions in Python — from the basic naive approach all the way to the optimal reversal algorithm used in real interviews.

The key takeaways: always compute k = k % n first, use slicing for readable code, and switch to the reversal algorithm when space matters. Handle edge cases like empty arrays and k = 0 before anything else.

Practice this problem on LeetCode (#189 – Rotate Array) and you’ll build strong muscle memory for array problems. Now you know the best ways to rotate array by k positions in Python. Happy coding! 🚀