CareerCup

const shiftK = (array, k) => {
    if (array.length < k){
        throw new Error("K should be less than array's length");
    }

    for (let i=0; i<k; i++){

        let temp = array[i];
        for (let j=i+k; j<array.length; j+=k){
            let newTemp = array[j];
            array[j] = temp;
            temp = newTemp;
        }

        array[i] = temp;
    }

    return array;
};

def fun(temp,k,i,l):
	#swap l[i] and temp
	swap_val=l[i]
	l[i]=temp
	temp=l[i]
	if(temp==None):
		return l
	else:
		return fun(temp,k,(i+k)%len(l),l)

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    let len = nums.length
    let portion = nums.splice(len - (k%len), len)

    nums.unshift(...portion)
};

void rotate(int in[], int l, int k){
	int cur = k%l;
	while(cur != 0){
		swap(in, 0, cur);
		cur = (cur+k)%l;
	}
}

function rotate(inp, l, k){
  let cur = parseInt(l - (k%l));
  let i=0;
	while(cur < l){
		let temp = inp[i];
		inp[i] = inp[cur];
		inp[cur] = temp;
		cur++;
    i++;
	}
  cur = k;
  key = parseInt(l - (k%l));
  key2 = key;
  while(cur < key){
		let temp = inp[key2];
		inp[key2] = inp[cur];
		inp[cur] = temp;
		cur++;
    key2++;
	}
  console.log(inp);
}

let arr = [1,2,3,4,5,6]; 
rotate(arr,arr.length,2);

public void rotate(int[] nums, int k) {
	       int n = nums.length;
	         if (n < 2)
	             return;
	        
	        k = k % n;
	        int count = 0;
	        for(int i = 0; count < n; i++){
	            int p = i;
	            int prev =nums[p];
	            do{
	                int j = (p + k) % n;
	               int temp = nums[j];
	                nums[j] = prev;
	                prev = temp;
	                p = j;
	                count++;
	            }while( p != i);         
	        }
	    }

static int[] rotateArrayConstantSpace2(int[] arr, int k) {
		if(k <= 0) {
			return null;
		}
		int temp;
		for(int i = 0, j = arr.length - k; i <= k-1 && j < arr.length; i++, j++) {
			temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
		return arr;
	}

public static int[] MoveLastToFirstInArray(int[] array, int k)
        {
            if (k < 0 || array == null || !array.Any())
            {
                return null;
            }

            var length = array.Length;

            if (k > length)
            {
                return null;
            }

            var i = k; 
            var j = 0;

            var newArray = array.Reverse().ToArray();

            while (i < length)  
            {
                newArray[i] = array[j]; 

                i++;
                j++;
            }

            return newArray;
        }

int [] swapAll_recur(int []arr,int k,int start)
{

if(start>=arr.length-1)
{
return arr;
}
// swap the kth element in the result right sub arry
for(int i=start;i<start+k;i++)
{
int temp=arr[i];
arr[i]=arr[arr.length-k+(i-start)];
arr[arr.length-k+(i-start)]=temp;
}
return swapAll_recur(arr, k,start+k);

}

Its simple rotate. Just traverse from back. Find the point by reducing index by k. P
Then reverse from 0 to p and p+1 to n-1
Thrn reverse whole array

Swift

let k = 2
        var l = [1,2,3,4,5,6]
        for _ in 0..<k {
            for i in stride(from: l.count - 1, to: 0, by: -1){
                if i > 0 {
                    l[i - 1] ^= l[i]
                    l[i] ^= l[i - 1]
                    l[i - 1] ^= l[i]
                }
            }
        }
	print(l)

int[] l = new int[]{1,2,3,4,5,6};
        int k = 2;
        int len = l.length;
        int cutIndex = len - k;
        for (int i = 0; i < cutIndex; i++) {
            l[k + i] = (i%(k + i)) + 1;
            if (i < k) {
                int itMove = l[i] + cutIndex;
                l[i] = itMove;
            }
        }
        System.out.println(Arrays.stream(l).mapToObj(it -> String.valueOf(it)).collect(Collectors.joining(", ")));

void shift(vector<int>& a, size_t k) {
  if (k == 0) return;
  if (k >= a.size()) throw runtime_error("Invalid argument: k");
  auto p = prev(a.end(), k);
  reverse(a.begin(), p);
  reverse(p, a.end());
  reverse(a.begin(), a.end());
}

Java solution:

public static int [] rotateArray(int [] arr, int k){
        for(int i = 0; i < k; i++){
            int j = arr.length-1, last = arr[j];
            while (j>0)
                arr[j]=arr[--j];
            arr[0] = last;
        }
        return arr;
    }

Time complexity: O(nk);

def r_rotate(l):
    temp = l[-1]
    for i in range(len(l)-1, 0, -1):
        l[i] = l[i-1]
    l[0] = temp

def rotate(l, k):
    #if len(l) == 1:
    #    return

    for i in range(k):
        r_rotate(l)


l = [1,2,3,4,5,6]
rotate(l, 2)
print(l)

l2 = [1]
rotate(l2, 2)
print(l2)

Am I misreading what is supposed to be done here?
Why are some solution accepting an array and two integers?

1 2 3 4 5 6
5 2 3 4 1 6
5 6 3 4 1 2
5 6 1 4 3 2
5 6 1 2 3 4

fun Array<Int>?.rotateBy(by: Int, start: Int = 0) {
fun Array<Int>.swap(i : Int, j : Int) {
val temp = this[i]
this[i] = this[j]
this[j] = temp
}
if (this == null || isEmpty()) {
return
}
val rotate = by % size
if (rotate <= 0) {
return
}
var i = start
var j = size - rotate
val stop = j
while (i < stop) {
if (j == size) {
j = stop
}
swap(i++, j++)
}
rotateBy(size - j, i)
}

fun Array<Int>?.rotateBy(by: Int, start: Int = 0) {
    fun Array<Int>.swap(i : Int, j : Int) {
        val temp = this[i]
        this[i] = this[j]
        this[j] = temp
    }
    if (this == null || isEmpty()) {
        return
    }
    val rotate = by % size
    if (rotate <= 0) {
        return
    }
    var i = start
    var j = size - rotate
    val stop = j
    while (i < stop) {
        if (j == size) {
            j = stop
        }
        swap(i++, j++)
    }
    rotateBy(size - j, i)
}