# Leetcode Rotate Array problem solution

In this Leetcode Rotate Array problem solution, You are Given an array, rotate the array to the right by k steps, where k is non-negative.

## Problem solution in Python.

```class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
for i in range(k):
lastValue = nums[len(nums)-1]
firstValue = nums[0]
del(nums[len(nums)-1])
nums.insert(0, lastValue)
```

## Problem solution in Java.

```public void rotate(int[] nums, int k) {
int n = nums == null ? 0 : nums.length;
if (n == 0)
return;
int offset = k%n;
int j = offset > 0 ? offset - 1 : n + offset - 1;
reverse(nums, 0, n - 1);
reverse(nums, 0, j);
reverse(nums, j + 1, n - 1);
}

private void reverse(int[] nums, int start, int end){
while(start < end){
int tmp = nums[start];
nums[start] = nums[end];
nums[end] = tmp;
++start;
--end;
}
}
```

## Problem solution in C++.

```class Solution {
public:
void rotate(vector<int>& nums, int k) {
int len = nums.size();
int d = gcd(len, k=k%len);
int pos, next_pos;
int tmp, tmp_next;

for (int i = 0; i < d; ++i) {
pos = i;
tmp = nums[pos];
do {
next_pos = (pos+k) % len;
tmp_next = nums[next_pos];
nums[next_pos] = tmp;

pos = next_pos;
tmp = tmp_next;
} while (pos != i);
}
}

int gcd(int a, int b)
{
int t;

while (b != 0) {
t = a%b;
a = b;
b = t;
}
return a;
}
};
```

## Problem solution in C.

```void rotate(int* nums, int numsSize, int k) {
if( numsSize < 2 || ( k % numsSize == 0 ) ) return;
for( ;k>numsSize; ) k = k % numsSize;
int* temp1 = (int*)malloc(sizeof(int)*k);
int* temp2 = (int*)malloc(sizeof(int)*(numsSize-k));
int count = 0;// counter
for(int i=(numsSize-k); count!=k; i++){ // afterwards
temp1[count] = nums[i];
count++;
}
for(int i=0; i<(numsSize-k); i++) temp2[i] = nums[i]; // forwards
for(int i=0; i<k; i++) nums[i] = temp1[i]; // forwards
for(int i=k; i<numsSize; i++) nums[i] = temp2[i-k]; // afterwards
}
```