Rotate Array by One

Given an integer array arr, rotate it by one position in the clockwise direction and return the result.

A clockwise rotation by one takes the last element and moves it to the front; every other element shifts one slot to the right. So arr = [1, 2, 3, 4, 5] becomes [5, 1, 2, 3, 4].

The array always has at least one element. A single-element array is unchanged by rotation.

Hints

· Stuck? Reveal one nudge at a time.

Only one element actually needs to travel a long distance — which one, and where does it land?

The last element jumps to the front; everyone else just slides one step toward the back. Can you do those slides without allocating a second array?

Save the last element, then copy each element one slot to the right — but sweep from the back to the front so you never overwrite a value before reading it.

Common doubts

Clockwise here means the last element wraps around to index 0. Counter-clockwise (a left rotation) would instead send the first element to the back, turning [1,2,3,4,5] into [2,3,4,5,1].

Either is accepted as long as you return the correctly rotated array. The optimal approach mutates in place for O(1) space; the brute-force approach returns a fresh copy.

Interview follow-ups

· What an interviewer asks next.

Rotating by k clockwise moves the last k elements to the front. The classic O(n)-time, O(1)-space trick is the reversal algorithm: reverse the whole array, then reverse the first k and the remaining n-k parts (take k mod n first).

Mirror the logic: save arr[0], slide every element one slot to the left with a front-to-back sweep, then drop the saved first element at the end.

Fun facts

Rotating by one is just rotating by k with k = 1 — and rotating by n (the array's length) lands you right back on the original, so all rotations live on a cycle of length n.
The three-reversal rotation trick reappears in text editors (moving a block of lines), circular buffers, and round-robin schedulers.

Asked at

AmazonMicrosoftAdobeGoogle

Frequently Sometimes Occasionally

Example 1

Input: arr = [1, 2, 3, 4, 5]
Output: [5, 1, 2, 3, 4]
The last element 5 moves to the front and the rest shift right by one.

Example 2

Input: arr = [9, 8, 7, 6, 4, 2, 1, 3]
Output: [3, 9, 8, 7, 6, 4, 2, 1]
The last element 3 comes to the first position; everything else slides one slot right.

Constraints

- 1 <= arr.size <= 10^5 - 0 <= arr[i] <= 10^5

Rotating an array by one looks trivial, and it is — but it's the cleanest place to learn a habit that saves you on every in-place array problem: the direction you sweep decides whether you corrupt your data. The brute force copies into a fresh array; the optimal does the same shift in place with a single saved variable.

Prerequisites

Before you start

· Concepts used directly in the solution.

Array traversal. Walking the array to shift elements — the whole operation is one directed pass.

In-place vs extra space. The trade-off between a clear second-array copy (O(n) space) and a careful in-place shift (O(1)).

Overwrite order. Reading a cell before you overwrite it — the reason the sweep direction matters.

Understand the problem

Given an array arr, rotate it clockwise by one: the last element moves to index 0, and every other element shifts one slot to the right. A single-element array is unchanged.

Worked example — arr = [1, 2, 3, 4, 5]

  before:  1  2  3  4  5
                        └──────┐  (last element wraps to front)
  after:   5  1  2  3  4          ✓

Clarifying questions

Questions to ask first

· Signals seniority before you write a line of code.

Input validity

“Clockwise or counter-clockwise?”

Clockwise here: the last element wraps to the front. Counter-clockwise (a left rotation) would send the first element to the back.

“Is the array guaranteed non-empty?”

Yes (at least one element); a single-element array is unchanged.

Edge cases

“What about a one-element array?”

Rotation leaves it exactly as it was — a useful check that your loop bounds don't misbehave.

Output format

“Return a new array, or mutate the input in place?”

Either is accepted. That choice is exactly the difference between the two approaches — a copy (O(n) space) or an in-place shift (O(1)).

Constraints & scale

“How large can the array be?”

Up to 10^5. Both approaches are O(n) time; the only axis to optimise is the extra space.

The ideal opening — say it like this

Two quick questions.

Is this a clockwise rotation — the last element moves to the front?

Am I allowed to mutate the input in place, or should I return a fresh array?

If in-place matters, I'll do it in O(1) extra space by shifting carefully.

Key observations

1Aha

Only one element travels far

A rotation by one isn't a big reshuffle: the last element jumps to the front, and every other element moves exactly one step. Seeing that "only the last one is special" is what makes an in-place solution obvious.

2Aha

You don't need a second array — just one temporary

Save the last element aside, slide everyone one slot to the right, then drop the saved value into index 0. A single temporary replaces an entire O(n) copy.

3Aha

Sweep back-to-front so you read before you overwrite

This is the transferable lesson. If you shift front-to-back, you overwrite arr[i] before the next step gets to read it — corrupting the array. Sweeping from the last index down to 1 (arr[i] = arr[i-1]) always reads a cell before it's overwritten.

Brute force vs optimal

	Copy into fresh array	In-place shift
Idea	Seed with last, copy the rest	Save last, slide right, drop at front
Time	O(n)	O(n)
Space	O(n)	O(1)
Mutates input?

The full code for both is in the Approaches selector below.

Summary

Key takeaway

Rotating by one is a one-slot shift with a single wrap-around, doable in O(1) space with one temporary. The real takeaway is the sweep direction: when you shift elements in place, move so that every source cell is read before it's overwritten — here, back-to-front.