# Rotate Array Elements

Write a function `rotateArray`

that rotates the elements of an array to the right by a given number of steps. Each step moves the last element of the array to the front and shifts all other elements to the right.

#### Constraints

- The input array can contain any number of elements.
- The number of steps for rotation will be a non-negative integer.
- The input array will not be empty.

#### Examples

```
Input: Array = [1, 2, 3, 4, 5], Steps = 2
Output: [4, 5, 1, 2, 3]
Explanation: Rotating the array 2 steps to the right, the elements 4 and 5 move to the front.
Input: Array = [10, 20, 30, 40], Steps = 1
Output: [40, 10, 20, 30]
Explanation: Rotating the array 1 step to the right, the element 40 moves to the front.
```

#### Tips

Consider using array slicing or deque from the collections module for an efficient solution.

Be mindful of the case where the number of rotation steps is greater than the array length. In such cases, use the modulo operator to calculate the effective number of rotations.

### Solution

### What’s the Exact `Rotate Array Elements`

Problem?

The problem is to rotate the elements of an array to the right by a specified number of steps. In each step, the last element of the array becomes the first, and all other elements shift one position to the right.

### Steps to Understand the `Rotate Array Elements`

Problem?

- Recognize that “rotating” the array involves moving elements from the end to the beginning.
- Understand that the number of rotations can be more than the length of the array.
- The challenge is to rearrange the elements according to the number of specified steps efficiently.

### Examples

```
Input: Array = [1, 2, 3, 4, 5], Steps = 2
Output: [4, 5, 1, 2, 3]
Explanation: After rotating 2 steps, elements 4 and 5 move to the front.
Input: Array = [10, 20, 30, 40], Steps = 1
Output: [40, 10, 20, 30]
Explanation: After 1 rotation, element 40 moves to the front.
```

### What Your `rotateArray`

Function Should Do?

The function `rotateArray`

should take an array and a non-negative integer representing the number of steps. It should return a new array that is the original array rotated to the right by the given number of steps.

### How to Solve the `Rotate Array Elements`

Problem?

- Calculate the effective number of rotations needed by taking the modulo of the number of steps by the array length.
- Use array slicing to rearrange the array elements.

### Example Code Solution

```
def rotateArray(arr, steps):
n = len(arr)
steps = steps % n # To handle more steps than elements in the array
return arr[-steps:] + arr[:-steps]
```

### Example Usage

```
print(rotateArray([1, 2, 3, 4, 5], 2)) # Output: [4, 5, 1, 2, 3]
print(rotateArray([10, 20, 30, 40], 1)) # Output: [40, 10, 20, 30]
```

### How this Code Works?

- The function first calculates the effective number of rotations by using the modulo operation. This is important for cases where the number of steps is greater than the length of the array.
- It then uses Python’s slicing feature to split the array into two parts - the last ‘steps’ elements and the rest.
- These parts are then concatenated in reverse order to achieve the desired rotation.

### Time Complexity:

The time complexity of this solution is O(n), where n is the number of elements in the array. This is because slicing an array in Python takes O(n) time. The space complexity is also O(n) since the solution creates a new array that is a rearrangement of the original array.