To solve the problem of rotating an array `A`

by `K`

positions to the right, we can follow a straightforward approach:

### Steps to Approach

If `A`

is empty (`N = 0`

), return an empty array since there’s nothing to rotate.

If `K`

is zero, return `A`

as it is since no rotation is needed.

Since rotating an array `N`

times where `N`

is the length of the array results in the same array, the effective number of rotations `K`

can be reduced to `K % N`

. This is because rotating an array `N`

times or any multiple of `N`

results in the array itself.

To rotate the array to the right by `K`

positions, the idea is to move the last `K`

elements of `A`

to the front and shift the rest to the right.

- This can be achieved by creating a new array where the elements from
`A[N-K]`

to`A[N-1]`

(last`K`

elements) are placed at the beginning, followed by the elements from`A[0]`

to`A[N-K-1]`

(remaining elements).

### Implementation in JavaScript

Here’s the implementation based on the outlined approach:

```
function solution(A, K) {
const N = A.length;
// Handle edge cases
if (N === 0 || K === 0) {
return A;
}
// Effective rotations
K = K % N;
// If no effective rotation needed
if (K === 0) {
return A;
}
// Create a new array for rotated result
const rotatedArray = [];
// Elements from A[N-K] to A[N-1] (last K elements)
for (let i = N - K; i < N; i++) {
rotatedArray.push(A[i]);
}
// Elements from A[0] to A[N-K-1] (first N-K elements)
for (let i = 0; i < N - K; i++) {
rotatedArray.push(A[i]);
}
return rotatedArray;
}
```

Handle cases where `A`

is empty or `K`

is zero directly to optimize and prevent unnecessary calculations.

By using `K % N`

, we ensure that we only rotate as many times as necessary (`K`

rotations effectively reduces to rotating `K % N`

times).

We split the array into two parts.

Elements from `A[N-K]`

to `A[N-1]`

are appended first (last `K`

elements).

Elements from `A[0]`

to `A[N-K-1]`

are appended next (remaining elements).

This approach effectively constructs the rotated array in a linear pass through the original array `A`

.

This implementation ensures correctness by adhering to the problem requirements and handles all specified edge cases.