Rotate Array - Practice Coding Problems

Rotate Array - Problem

Array Rotation Challenge: You're given an integer array nums and need to rotate it to the right by exactly k steps. Think of it like a conveyor belt - elements that fall off the right end wrap around to the beginning!

For example, if you have [1,2,3,4,5] and rotate right by 2 steps, elements 4 and 5 move to the front, giving you [4,5,1,2,3].

Goal: Transform the array in-place (modify the original array) to achieve the rotation efficiently.

Input & Output

example_1.py — Basic Rotation

$ Input: nums = [1,2,3,4,5,6,7], k = 3

› Output: [5,6,7,1,2,3,4]

💡 Note: Rotating right by 3 steps: elements 5,6,7 from the end move to the front, and 1,2,3,4 shift right

example_2.py — Small Array

$ Input: nums = [-1,-100,3,99], k = 2

› Output: [3,99,-1,-100]

💡 Note: With k=2, the last 2 elements (3,99) move to the front, and the first 2 elements (-1,-100) move to the end

example_3.py — k Larger Than Array

$ Input: nums = [1,2], k = 3

› Output: [2,1]

💡 Note: k=3 is equivalent to k=3%2=1, so we rotate right by 1 step: [1,2] becomes [2,1]

Visualization

Tap to expand

Understanding the Visualization

Flip Entire Deck

First, flip the entire deck upside down

Flip First k Cards

Then flip just the first k cards back

Flip Remaining Cards

Finally, flip the remaining cards back

Key Takeaway

🎯 Key Insight: Any array rotation can be achieved with exactly three reversals: reverse all, reverse first k, reverse last n-k. This transforms a complex problem into simple array manipulations!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is moved exactly once, so we do n operations total

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables to track current position and temporary values

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
0 ≤ k ≤ 2³¹ - 1
Follow-up: Try to solve in-place with O(1) extra space

Asked in

⊞ Microsoft 45 a Amazon 38 G Google 32 f Meta 28

The optimal solution uses the three-reversal technique: reverse the entire array, then reverse the first k elements, then reverse the remaining elements. This achieves O(n) time and O(1) space complexity, making it the most efficient approach for in-place array rotation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (One Step at a Time)	O(n*k)	O(1)	Rotate the array one position at a time, k times
Cyclic Replacements (Optimal)	O(n)	O(1)	Use cyclic replacements to move elements in-place with O(1) extra space
Extra Array Approach	O(n)	O(n)	Use an extra array to place elements directly in their final positions

Brute Force (One Step at a Time) — Algorithm Steps

Repeat k times:
Save the last element of the array
Shift all elements one position to the right
Place the saved element at index 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with [1,2,3,4,5], k=2

First Rotation

Save 5, shift all right, place 5 at start: [5,1,2,3,4]

Second Rotation

Save 4, shift all right, place 4 at start: [4,5,1,2,3]

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void rotate(int* nums, int numsSize, int k) {
    k = k % numsSize; // Handle k > numsSize
    
    for (int step = 0; step < k; step++) {
        // Save last element
        int last = nums[numsSize - 1];
        // Shift all elements right by 1
        for (int i = numsSize - 1; i > 0; i--) {
            nums[i] = nums[i - 1];
        }
        // Place last element at beginning
        nums[0] = last;
    }
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    int size = 5;
    int k = 2;
    rotate(nums, size, k);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We perform k rotations, each taking O(n) time to shift all elements

✓ Linear Growth

Space Complexity

O(1)

Only uses one variable to store the last element temporarily

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
0 ≤ k ≤ 2³¹ - 1
Follow-up: Try to solve in-place with O(1) extra space

42.9K Views

High Frequency

~15 min Avg. Time

1.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (One Step at a Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler