same here. I know it's too late to reply :P

he's doing mod caz after n rotation all elements will come at same position as starting point.

Java mod solution:

for(int i = 0; i < numQueries; i++) {
    System.out.println(array[(arraySize + (in.nextInt() - (numRotations % arraySize))) % arraySize]);
}

Test case 4? Segmentation fault?

wow!!! fast and easy way to done the problem..

Thank you!

Now I know %=

Really great solution!

Thanks polmki99! Very clever implementation.

Here it is in Javascript for those interested.

function processData(input) {
    //Enter your code here
    var inputList = input.split('\n');
    var details = inputList[0].split(" ");
    var arrayIdx = inputList.slice(2);
    var targetArray = inputList[1].split(" ");
    
    var k = details[1]%details[0];
    
    targetArray = [].concat(targetArray.slice(-k),targetArray.slice(0,-k));
    
    arrayIdx.map(function(elem){return console.log(targetArray[elem]);});
}

how about my solution is it good..

n,k,q = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
a = a[n-(k%n):]+a[0:n-(k%n)]
[print(a[int(input())]) for _ in range(q)]

smart one more way u could have actually stored rotated version of array while taking array input.

bunny?

Query will be O(1) time complexity regardless of the implementation or correctness since you are accessing an indexed array. Your solution did not make accessing more efficient anymore than it is, but since you are inserting into an array in O(n) time and correctly accessing it passes all tests.

It is O(1) per query. This problem can be solved without actually rotating the array.

Here is my solution Circular Array Rotation

I really like this one Zeus! I tried to make it more compact:

n, k, q =   map(int, input().strip().split())
a       =   [int(i) for i in input().strip().split(' ')]
for i in range(q):
    m   =   int(input())    
    print(a[(m-k)%n])

Yeah, it does

a,arr = [map(int,raw_input().split()) for _ in range(2)] for _ in range(a[2]): print (arr[-(a[1]%a[0]):] + arr[:-(a[1]%a[0])])[input()]

Visit here. I have explained it in detail.

Because when the number of rotations(k) equals the size of the array(n), the array returns to it's original setup. For example, after 3 rotations, this array is back to original:

[1,2,3] 0 original
[3,1,2] 1 rotation
[2,3,1] 2 rotations
[1,2,3] 3 rotations //Back to original setup
[3,1,2] 4 rotations // same as 1 rotation

Therefore if you have 4 rotations, then 4 % 3 is 1, so you will get the same result as if you only had 1 rotation to begin with.

It's just because in the '(rot-1)th' elements of the array you will have negative indexes, causing errors or, even, segmentation error (as in test case 4). So, doing this, you add N to negative indexes to retrive the correct values from the former array, without rotating it at all.

Well, let's try explain using an example case:

If I have an array(a) with, let's say, N=5 elements: a0=0, a1=1, a2=2, a3=3 and a4=4.
Let's consider that I have to rotate this array K=6 times.

So:
a0={0, 1, 2, 3, 4} (initial array)

When I right-rotate 6 times this array, following the rules estipulated in this problem, I'll get this:

a1={4, 0, 1, 2, 3} (1st rotation)
a2={3, 4, 0, 1, 2} (2nd rotation)
a3={2, 3, 4, 0, 1} (3th rotation)
a4={1, 2, 3, 4, 0} (4th rotation)
a5={0, 1, 2, 3, 4} (5th rotation)
a6={4, 0, 1, 2, 3} (6th rotation)

Observe that at the 5th rotation, we got the original array again (a5 == a0). In fact, at every N rotations we'll get the original array. So, we don't need to rotate the array K times if K is greater than N. We can just rotate it (K%N) times (rest of integer division, or just 'modulo operation'). In my example 6%5 = 1.

And, even in this case, I don't need to actually rotate the array, but just retrieve an element from the array whose position is 1 lower than it was in the original array.
WHAT???
Yes, let's consider the initial array and after 1 or 6 rotations, as follows:
a0={0, 1, 2, 3, 4}
a1={4, 0, 1, 2, 3} (1st and 6th rotation)

If I try to retrieve the:
- 4th element, I'll get 3;
- 3rd element, I'll get 2, and so on.
Thus, if I subtract the number of rotations(K) from the index of the element, I'll get its value after K rotations, correct?
YES and NO!!!
a1[4] == a0[3]
a1[3] == a0[2]

Hummm... aK[m] == a0[m-(k%N)]! Great. No rotation is necessary, but just a simple calculation...
Let's continue...

a1[2] == a0[1]
a1[1] == a0[0]
a1[0] == a0[-1] OPS! There's no a[-1]!!!

Here we get an error type "Index out of bounds". It's because we are trying to acces memory positions that are out of the array's boundaries. Probably, it is being used by another variable. A "Segmentation error" message may appear when K is much bigger than N (something like k=100000 and n=515, as in test case 4). It's because we are trying to acces memory positions that are out of the program boundaries and, probably, are being used by another application.

To correct these errors, we can use the same solution we used to simulate the K>N rotations: modulo operation!
The answer would be like this:
aK[m] == a0[(m+N-(K%N))%N].

We add N to the index to assure it will never be negative.

Tricky, fast and easy.
Try implementing this in your application.

I hope be helpful ;-)