Rotate List

Given a list (or array) of elements, you need to rotate it to the right by a specified number of steps. This operation is common in various data manipulation tasks, such as cyclical shifts or reordering elements in a structured manner.

Problem Description

You are tasked with implementing a function that takes a list and an integer k as input. The function should rotate the list to the right by k positions. Rotating to the right means that the last k elements of the list will be moved to the beginning, and the remaining elements will shift to the right accordingly.

Key Requirements:

• The rotation should be performed in-place if possible, or a new rotated list should be returned.
• The value of k can be greater than the length of the list, or zero.

Expected Behavior:

• If k is 0, the list remains unchanged.
• If k is positive, the list rotates to the right.
• If k is negative, the behavior is undefined for this challenge, but you should consider how you might handle it or state that it's not supported. For this challenge, assume k will be non-negative.
• If the list is empty, it should remain empty.

Edge Cases:

• Empty list.
• k is equal to the length of the list.
• k is greater than the length of the list.
• k is 0.

Examples

Example 1:

Input: List = [1, 2, 3, 4, 5], k = 2
Output: [4, 5, 1, 2, 3]
Explanation:
1. Rotate 1: [5, 1, 2, 3, 4]
2. Rotate 2: [4, 5, 1, 2, 3]

Example 2:

Input: List = [0, 1, 2], k = 4
Output: [2, 0, 1]
Explanation:
Rotating by 4 is the same as rotating by 1 (4 % 3 = 1) since the list has 3 elements.
1. Rotate 1: [2, 0, 1]

Example 3:

Input: List = [], k = 1
Output: []
Explanation: An empty list remains empty regardless of rotation.

Example 4:

Input: List = [1], k = 5
Output: [1]
Explanation: Rotating a list with one element by any amount results in the same list.

Constraints

• The list can contain any type of elements (integers, strings, etc.).
• The length of the list can be between 0 and 1000, inclusive.
• The value of k will be between 0 and 1000, inclusive.
• Your solution should aim for an efficient time complexity, ideally O(N) where N is the length of the list.

Notes

• Consider how to handle k values that are larger than the list's length. The modulo operator (%) can be very useful here.
• Think about different strategies for rotation:
  • Creating a new list.
  • Using multiple reversals.
  • Shifting elements one by one (though this might be less efficient).
• Success will be measured by the correctness of the output for various inputs, including edge cases, and by meeting the performance expectations.