Neat code , thanks Hitscotty !!

hmm.. I'm surprised that worked for you. This one worked for me:

str = ''

length_of_array.times do |i|
  new_index = (i + no_of_left_rotation) % length_of_array
  str += "#{array[new_index]} "
end

puts str.strip

I guess the logic fails if the input is as follows: 5-n 6-d 1 2 3 4 5

The question asks to shift a fully formed array, not to shift elements to their position as they're read in. Start with a fully formed array, then this solution does not work.

I had the same idea! Just find the starting point of the array with the shift and count on from there, taking modulo and the size of the array into account.

(i + shift) % lenght Should be enough

modular arithmetic is cool. I solved that way too

for idx in range(0, _size):
  indexes[(idx - shift + _size) % _size] = _list[idx]

what if newLocation becomes negative

What if lengthOfArray < shiftAmount? I think you should use abs value

Aweosme !!!

pretty simple in js:

a.splice(k).concat(a.slice(0, k)).join(' ')

nice one

i think that the new location = ((i + Shift)) % lenght of array

godlike solution.

this doesnt work if you shift by 3.

Spoiler! You can do it even simpler: rotated[i] = a[(i + k) % n]. Also spoilers should be removed from the discussion or the discussion should only be available after solving. I will complain about this until its changed :P

Very nice.

@hitscotty what brought you to modular arithmetic for this solution?

what if shiftAmount is greater than length of array

your solution is cool but if you have an array as input then you are in trouble bcoz in that case you have space complexity of O(n) as you need an another array to store element in new place.. think..

It is not following the instructions. Sorry.

Great Logic!! Thank you so much!!

can u pls expalin what is shiftAmount???

Hey @Hitscotty! What will be the newLocation if you wish to do a right rotation?

Hey, guys
Here is a solution based on modular arithmetic for the case when k > n:

new_index = (n + i - abs(k-n)) % n

(note: n - abs(k-n) can be collapsed to a single number)

This only work when you read directly from input. But in the question they have asked to do rotation operation only on Array, so your solution cannot be used for this problem.

I understand how this works, but how did you think of it?

This will also fail when my shiftAmount = 7 and lengthOfArray = 3, in short lengthOfArray is less than shiftAmount. In this case we can use Math.abs(). for(int a_i=0; a_i < n; a_i++){ int new_index = Math.abs((a_i + (lengthOfArray - shiftAmount))) % lengthOfArray ; a[new_index] = in.nextInt(); }

Superb man.....

That's nice but its kinda cheating :)

Well done! I did it by finding the correct number for the index, rather than the new position of a given number:

for (int i =0; i < n; i++){
    int num = a[((n + k) % n + i) % n];
    System.out.print((num) + " ");
}

very good, thanks!!!

can u please elaborate some more about your code as i dont have much knowledge about modular maths

the requirement is to take an array and left rotate the array d times. Your solution returns the correct result, but takes an integer one at a time.

what is in.nextInt() here.

Thanks for sharing this code it really helpped. I felt the constraints were to be includes by ifstatements but after viewing your code I was able get it. I have a small suggestion, would it improve the code if one were to seperate the (LengthOfArray - ShiftAmount) part into a variable and then reuse it since its kind of a constant value. Once again kudos.

what is the use of in.nextInt(),will u plz explain me.

Neat code, the only possible optimization is extra space used. even for a single rotation on say 1 million elements, the algo is greedy on space and will create 1 million auxilary elements.

Brilliant

what is in.nextInt() which language is that did you create another scanner object of in can you be more specific?

Very celever! thanks.

reverse it

arr1=a[0:d]

arr2=a[d:]

return arr2+arr1

It's easy when you directly read them from system input. Try to make it work on already stored array. That's what problem statement says. It gets tricky and interesting after that to solve it in o(n) without extra memory.

i.e. // Complete roLeft function

My solution

private static int getIncomingIndex(int index, int rotations, int length) {
    if(index < (length - rotations)) {
        return index + rotations;
    }
    return index + rotations - length;
}

// Complete the rotLeft function below.
    static int[] rotLeft(int[] a, int d) { 
           int rotations = d % a.length;

    if(a.length == 0 || a.length == 1 || rotations == 0) {
        return a;
    }

    if( a.length % 2 == 0 && a.length / 2 == rotations) {
        for(int i =0 ; i < a.length / 2 ; i++) {
            swap(a, i, i + rotations);
        }
    } else {
        int count = 0;
        int i = 0;
        while(true) {
            int dstIndex = getIncomingIndex(i, rotations, a.length);
            swap(a, i, dstIndex);
            i = dstIndex;
            count++;
            if(count == a.length - 1) {
                break;
            }
        }
    }
    return a;
}

nice code tq

The part I'm missing here is why use a loop (O(n)). Can't you take the array and find the effective rotation based on the shift amount (using the same modular arithemetic you're doing? (Which is now O(1) since the length of the array is a property)

function rotLeft(a, d) {

  //calculate effective rotation (d % a.length)
  let effectiveRotation = d % a.length;

  // split a at index of effective rotation into left and right
  let leftPortion = a.slice(0, effectiveRotation);
  let rightPortion = a.slice(effectiveRotation); 
	
  // concat left to right
  return rightPortion.concat(leftPortion)
}

vera level..!

Why would you loop for every element when in essence the rotation operation is nothing but just a rearrangement of the array elements in a specified fashion?

helps a lot

Verry Good!

I saw this answer in stackoverflow too.. Please be kind enough to explain this.
Thanks

Tried a different approach

def rotLeft(a, d): return reversed(list(reversed(a[:d])) + list(reversed(a[d:])))

But isn't the whole point that you are not placing them as they come, the array is pre-populated and then rotate it. My solution is O(dn), not sure if there is anything better. Clearly I am not an algorithm guy (anymore)!

for (int i = 0; i < d; i++) { int pop=a[0]; //shift left for (int j = 1; j < a.length; j++) { a[j-1] = a[j]; } //push a[a.length-1]=pop; }

Excellent !!! I am new to problem solving. I had solved it via normal shifting using one for loop and one while loop. How did you arrive at this kind of solution?? Little bit of explanation as what you thought while solving this would help a lot.

Thanks.

How can I do this in C++?

a[newLocation] = in.nextInt();

If the number of rotations are greater than array length (I know it's less than array length which is given in the question, let us assume), then how would this formula change? BTW That's a great way to get the array indices without having to traverse the whole array

Interesting take on the problem!

I'm just mentionning this for completeness' sake but not actually solving the problem as asked, which is to write a separate function :)

Also, a follow-up question might be "improve your function so that it rotates the array in-place"

Nice solution! Thanks for sharing :)

How do you people come up with such optimization? my mind doesn't seem to work :(

I was thinking to do the same but thought not gonna do this with arithmetic so I just looped twice.

let result = [];
for(let i = shiftAmount; i < array.length; i++){
    result.push(array[i]);
}
for(let i = 0; i < shiftAmount; i++){
    result.push(array[i]);
}
return result;

sorry to bother..i'm having trouble calculating for these values.. array length=5, no._of rotations=7.

if i take i=0 i=(0+(5-7)%5); which is equal to -2??

what am i doing wrong?

Great solution! It's possible to simplify that by finding new position as:

newPos = (i - d)%length

optimise by returning array if lenght and rotations are same

what if shift amount is negative?

for(int i = 0; i < lengthOfArray; i++){

        int newLocation = (i + (lengthOfArray - abs(shiftAmount))) % lengthOfArray;
        a[newLocation] = in.nextInt();
}

In js, I tried a different approach. In node.js, it has no difference in performance when it is compared to other approach.

function rotLeft(a, d) {
    let i = 0, j = i + d;
    let arr = [];

    while (i < a.length) {
        if (j < a.length) {
            arr[i] = a[j];
            j++;
        } else {
		 j = 0;
        }
     i++;
    }
    return arr;
}

my one liner solution

return a[d:] + a[:d]

where a is the arraya and d is the number of rotation

static int[] rotLeft(int[] a, int d) { int size=a.length; int [] arr=new int[size]; for(int i=0;i

}

I think there is no need of any maths or what you did. Well what i do is down below, more simple and works for all test cases.

#a = given_array
#d = given number of left rotations to be done
b = []
b.append(a[d:])
b.append(a[:d])