Easy 0 solved 0% acceptance

Rotate Array

Rotate a list to the right by some steps.

What you'll learn

  • Shift elements with index arithmetic
  • Reduce large rotations with modulo
  • Build a rotated copy of a list

Problem

Rotate the list to the right by steps positions: the last element moves to the front, steps times.

Implement rotate_right(numbers, steps).

Input

numbers: The list of integers. steps: How many positions to rotate.

Output

Return the rotated list.

Constraints

0 ≤ length ≤ 100,000; 0 ≤ steps ≤ 10⁹

Examples

Example 1
Input:
steps = 2
numbers = [1, 2, 3, 4, 5]

Expected output:
expected = [4, 5, 1, 2, 3]
Input:
long long steps = 2;
std::vector<long long> numbers = {1, 2, 3, 4, 5};

Expected output:
std::vector<long long> expected = {4, 5, 1, 2, 3};
Input:
long steps = 2;
long[] numbers = new long[] {1, 2, 3, 4, 5};

Expected output:
long[] expected = new long[] {4, 5, 1, 2, 3};

Explanation

Two right rotations: [5, 1, 2, 3, 4], then [4, 5, 1, 2, 3].

Example 2
Input:
steps = 3
numbers = [1, 2, 3]

Expected output:
expected = [1, 2, 3]
Input:
long long steps = 3;
std::vector<long long> numbers = {1, 2, 3};

Expected output:
std::vector<long long> expected = {1, 2, 3};
Input:
long steps = 3;
long[] numbers = new long[] {1, 2, 3};

Expected output:
long[] expected = new long[] {1, 2, 3};

Explanation

Rotating by the length brings the list back: [1, 2, 3].

How to approach it

Try on your own first, then open one hint at a time.

Hint 1

A rotation by the list length changes nothing, so only the remainder matters.

Hint 2

Think of splitting the list near the end and moving that tail to the front.

Hint 3

Handle very large step counts by reducing them before rearranging.

Expected complexity

O(n) time, O(n) extra space

References

This challenge is adapted for CodeUtility. Follow the statement and constraints above.

Learn from others

Community solutions

No published solutions yet. Solve this challenge to share the first one.