Циклическое вращение массива в решениях кодируемости Python и C ++, Урок 2

Hello,

Thanks for sharing your creative solutions for Codility!

This video is not working, kindly check it :)

That modulo is tricky to figure out, I first used minus instead. All the test cases ran correctly but I got 62% because it wouldn't work for K > 2*len(A). Guess moral of the story is to always test a couple of extreme cases at least once, like K = 1000 or something like that.

arr [:n]+ arr[n:] ??? sir can we do in this way or whats problem??

Would this work?
def cyclic_array(arr,k):
k_new = k%len(arr)
new_index = 0
new_arr = [0 for i in range(len(arr))]
for i in range(len(arr)):
new_index = i + k_new
if new_index > len(arr)-1:
new_index = new_index - len(arr)
new_arr[new_index] = arr[i]
else:
new_arr[new_index] = arr[i]
print(new_arr)

Am i cheating by doing this:

N = len(A)
counter = 0

while counter != K:
A.insert(0, A[N-1])
A = A[:-1]
counter += 1

It seems a lot less complicated.

Can somebody explain me how this function work B[(i+K)%N] = A[i] i didn't understand logic, thank you very much.

Thanks a lot for the explanation !
this is my try in python

def solution(A,k):
n = len(A)
k_1 = k %n
return A[n-k_1:] + A[:n-k_1]

def cyclic(k: int, arr: list) -> list:
size: int = len(arr)
movement: int = k % size
return arr[-movement:] + arr[:-movement]

tested the above version and it was twice as fast as the version below

def cyclic(k: int, arr: list) -> list:
size: int = len(arr)
cycled: list = [None] * size
for i, v in enumerate(arr):
cycled[(i+k)%size] = v
return cycled

Compilation successful.

Example test: ([3, 8, 9, 7, 6], 3)
OK

Example test: ([0, 0, 0], 1)
OK

Example test: ([1, 2, 3, 4], 4)
OK

Your test case: def solution(A, K):
RUNTIME ERROR (invalid input, unexpected character: :)

Your test case: if len(A) == 0:
RUNTIME ERROR (invalid input, unexpected character: =)

Your test case: return A
RUNTIME ERROR (invalid input, unexpected 'return', expecting integer)

Your test case: K = K % len(A)
RUNTIME ERROR (invalid input, unexpected character: =)

Your test case: return A[- K:] + A[:-K]
RUNTIME ERROR (invalid input, unexpected character: -)

Detected some errors.

Can you please explain me why codility detected those errors?

def solution(A, K):
# This function returns an array of elements shifted to the right k times
# 100% solution

if not(A): # Check if there are elements in the list
return A # Return empty list if no elements in the list

num_elements = len(A) # Initialize number of elements in list
for _ in range(K): # Loop through times to shift each element (e.g. shift position of elements 3 times)
A.insert(0, A[num_elements-1]) # Insert element of last index in first index of the list (done each time)
A.pop() # Remove last element from list each time
return A

Is it good?
def cyclic_array_rotation(k, a):
for x in range(k):
holder = a.pop()
a.insert(0, holder)

function cyclicRotation(A: number[], K: number): number[] {
const L = A.length;
const R = L - (K % L);
const arr = A.splice(R);
return [...arr, ...A];
}

console.log("==> ", cyclicRotation([3, 8, 9, 7, 6], 3)); // [9, 7, 6, 3, 8]
console.log("==> ", cyclicRotation([0, 0, 0], 1)); // [9, 7, 6, 3, 8]
console.log("==> ", cyclicRotation([1, 2, 3, 4], 4)); // [9, 7, 6, 3, 8]
console.log("==> ", cyclicRotation([1, 1, 2, 3, 5], 42)); // [3, 5, 1, 1, 2]

This is the best channel to explain the logic of the algo... practice these enough in your language then ask for 200k!