can i get an explanation,pls?

your code is very small and still work fine, will you explain me how [(i+n-d)%n] is working here. please actually why you are using % here thats making me confuse

This is my C# sharp code.

        string[] s1 = Console.ReadLine().Split(' ');
        int n = int.Parse(s1[0]);
        int k = int.Parse(s1[1]);

        string[] s = Console.ReadLine().Split(' ');
        int[] array = new int[n];

        ////pre-rotation of array method:
        //-----------------------------------Right rotation
        //for (int i = 0; i < n; i++)
        //{
        //    array[(i + k) % n] = int.Parse(s[i]);
        //}

        //------------------------------------Left rotation
        for (int i = 0; i < n; i++)
        {
            array[(i + (n-k)) % n] = int.Parse(s[i]);
        }

        for (int i = 0; i < n; i++)
        {
            Console.WriteLine(array[i]+" ");
        }

Did anyone consider if we cant alloc a new array to store sorted array, only operate the old array to left rotation?

Is it possible to do the same in C# using only one array (as one array must hold the splitted values and other to place them accordingly) ?

厉害，佩服

Thumbs up, for sharp thinking. Complicated my solution before stumbling on the same short solution myself :D

"A left rotation operation on an array of size n shifts each of the array's elements d unit to the left."

This isn't a correct solution. It's merely masking itself to be a solution. It's taking input and stuffing it pre-ordered into a new array. You should be doing a left rotation on an existing array.

move that n-d outside the loop its always same. other then that your solution is best.

your time complexity : O(n + n) your space complexity : n

you can optimize it a little bit with :

time complexity : n + d space complexity : d

public static void main(String[] args) { Scanner c = new Scanner(System.in); int n = c.nextInt(); int d = c.nextInt(); int skipPart[] = new int[d]; int j =0; for(int i = 0; i < n; i++) { if(i >= d) { System.out.print(c.nextInt() + " "); } else { skipPart[j] = c.nextInt(); j++; } } for(int i = 0; i < skipPart.length; i++) { System.out.print(skipPart[i] + " "); } }

I like this I wish I'd came to this algorithm myself ...

Similarly:

public static void main(String[] args) {       
        Scanner sc = new Scanner(System.in);        
        int n = sc.nextInt();
        int d = sc.nextInt();
        int array[] = new int[n];        
        for (int i=0; i<n; i++) {  array[i] = sc.nextInt();  }
        for (int i=0; i<n; i++) {  System.out.print(array[(i+d)%n] + " "); }
    }

A really good solution. I was unable to figure it out mathematically XD.

very clever, thanks!

What a great hack, akueisara39! Given that the defaulted code that read the elements into an array, I saw myself forced to use additional space.

Can someone explain how you came about the formula (i+n-d)? I am not able to understand how that formula is derived?

good logic akueisara. i used similar logic like "(i+n-d)%n" in circular linked list.

it is just awesome. I want to ask how you think this way, while everybody else is concentrating on different point, your solution is really different and cool :) My understanding is you approach the problem right at the beginning, the only issue is the coming up with this formula "(i+n-d)%n" good thinking akueisara39

It is a greate solution.

I think something similar, but your solution is better.

Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int d = scanner.nextInt() % n;
int arr[] = new int[n];
for (int i = 0; i < n; i++) {
    arr[i] = scanner.nextInt();
}
scanner.close();

for (int i = d; i < n; i++) {
    System.out.print(arr[i]);
    System.out.print(' ');
}
for (int i = 0; i < d; i++) {
    System.out.print(arr[i]);
    System.out.print(' ');
}
System.out.println();

int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    int i,d,k,n,temp,j;
    cin>>n;
    int a[n];
    
    for(i=0;i<n;i++)
        cin>>a[i];
        
    cin>>d;
            
            for(i=0;i<n;i++)
           cout<<" "<<a[(i + (n - d)) % n];
    return 0;
}

pls let me knw wats wrng in this?

My C solution was similar:

int main() {
    int n;
    int d;
    int temp;
    int *array = (int *)malloc(sizeof(int) * n);
    
    scanf("%d", &n);
    scanf("%d", &d);
    
    for(int i = 0; i < n; i++){
        temp = i - d;
        if(temp < 0){
            temp = temp + n;
        }
        scanf("%d", &array[temp]);
    }
    
    for(int i = 0; i < n; i++){
        printf("%d ", array[i]);
    }
   
    return 0;
}

It can be optimized in terms of space if you don't store the whole array, but only the rotated elements. If the elements are 1 2 3 ... 100000, and the number of left rotations is 2, you can save the first two elements (1 and 2) and directly print the rest as soon as you read them. Finally, print the saved ones. The difference in space is from 100000 ints to 2 ints.

How come you reached to this logic array[(i+n-d)%n], i understood what you did here but, having hard time to understand how did you get to this formula, does it comes with expreince or some mathematical practice i am lacking. Thanks

Pure Magic !!!

The logic does it in one loop. Brilliant.

Very creative solution!

3 errors is generating

public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); int d = in.nextInt(); int[] array = new int[n]; int c=0,i,temp; for(i=0; i

            temp=array[0];
    for(i=0; i<n;i++) {
        array[i]=array[i+1];
    }
       array[n]=temp;
        c++;
     for(i=0; i<n;i++) {
        System.out.print(array[i]);
    }  
}

} }

what is the issue if i write this way.

Awesome , this really saves time .Thank You..!!

I was thining on the same lines after I got the timeout error. But didn't reach anywhere, I was still using the same number of For loops some how! Thanks a lot!

So without using an extra array u did it. Basically u dont have an input array.. Great

is the array[(i+n-d)%n] is some standard algo?

suppose if i enter value of n=5;d=2; then it will accept five numbers not more than that but if i wil not hit the Enter key then it will have been accepting the many values i will hav to take only 5 values not more than that

Awesome...

amazing!!

¿This works for you? In my analysis, this does a right rotation instead of a left rotation. Isn't it? You should implement the logic for translate right to left rotations or to invert the direction.

Nice

Hi akueisara39 : i appreciate your code as it appears to be out of box solution . but i feel it throws an exception when the number of shift operations is greater than the size(d>n) of the array so just added few lines of code to it .

int[] array = new int[n]; if(d>n) d=d%n; for(int i=0; i array[(i+n-d)%n] = scan.nextInt();
}

Instead of rotating each element we can just cut the string upto that index and paste(append) it at the end of the string.

A solution for python would be

def leftrotation(a,d):
    return(a[d:]+a[:d])

Here's my solution in Kotlin. I did it using circular LinkedList. data class Node(val value: Int, var nextNode: Node?)

fun main(args: Array) { val (n, d) = readLine()!!.split(" ").map(String::toInt) val list = readLine()!!.split(" ").map(String::toInt) var head = Node(list[0], null) var current = head var rotatedHead = head for (i in 1 until n) { val node = Node(list[i], null) current.nextNode = node current = node if (i == d % n) rotatedHead = node } current.nextNode = head

current = rotatedHead
repeat(n) {
    print(current.value.toString() + " ")
    current = current.nextNode!!
}

}

genius!

I liked your approach.But I would like to pin point one thing here as you have been already given an array and N number of rotation.ON that array you have to perform operations.You are changing it while reading from console. please have a look at this and let me know if this can be optimized.

static int[] leftRotation(int[] a, int d) { // Complete this function

        int[] b= new int[a.length];
        for(int iLoop=0;iLoop<a.length;iLoop++){
            b[iLoop]=a[iLoop];
        }
        for(int iLoop=0;iLoop<a.length;iLoop++){
           a[iLoop]=b[(iLoop+d)%a.length]; 
        }
    return a;
}


But Really good solution though.

how did you do that it is amazing...how can you think like that.....

nice explanation genius

Brilliant

very cool way of doing!

Your approach to this problem was great and one correction if d > n then in those cases you should recompute d as d = d%n;

cool! i mean hats off

If the number of rotations is greater than the number of elements, than this can still throw an IndexOutOfBounds as (i+n-d) is negative.

To solve this one can use a true modulus function like Math.floorMod(i-d, n) which rather than returning the remainder returns a modulus. https://stackoverflow.com/questions/5385024/mod-in-java-produces-negative-numbers

Yes this code is useful.

wow bro you are great

array[(i+n-d)%n] = scan.nextInt();

How did you come up with this idea? I was puzzled with this task for two days and still didn't succeed in it...

hey, your logic is cool . but i dont understand it . like i am not able to figure out how it works (in the logical sense ) . why do you add n in(i+n-d)? It would be really nice if you explain . thank you

what a piece of outstanding code........well done

Nice....

Just calculate the effective number of rotations d % n and then simply change the list accordingly. Simple Pythonic solution with O(1) complexity:

def rotate(a, r):
    l = a[r:] + a[:r]
    return l


if __name__ == '__main__':
    nd = input().split()

    n = int(nd[0])

    d = int(nd[1])

    a = list(map(int, input().rstrip().split()))

    r = d % n

    print(*rotate(a,r)) 

Thank you, GOOD EXPLANATION

I have coded the same logic in c++ and I am getting a segmentation fault.

If you're looking for something more easy to understand:

public class Solution {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int d = scan.nextInt();
        
        int[] array = new int[n];
        for(int i=0; i<n;i++) {
            if(i-d < 0)
                array[n+(i-d)] = scan.nextInt();
            else
                array[i-d] = scan.nextInt();
        }
        for(int i=0; i<n;i++) {
            System.out.print(array[i] + " ");
        }      
    }
}

Another method for those who are concerned about manipulating existing array:

for(int i=1;i<n+1;i++)
 {
     if(i<=n-d)
     {
         cout<<a[(i+d)-1]<<" ";
     }
     else
     {
        cout<<a[(i-n+d)-1]<<" ";
     }
 }

Good job, bro!

Why not to use Collections.rotate()

Amazing

wow.. super,What a logic... nice###:)

It will not work out if d>n.

came to the comments for the lulz was impressed instead! thats a very clever way of doing it

static int[] rotLeft(int[] a, int d) { //d= d%5;

       int [] r = new int[a.length];

    for(int i=0; i<a.length; i++){

        r[i]= a[(i+d)%5];

    }
    return r;

}

Great solution. Congratulations.

this works only when d<=n/2.

If "d" is greater than "n" , for example take n=5 and d = 10 let me take arr[5] = {1,2,3,4,5} for 10 rotations ans should be same right but it does not work!!! 5 10 1 2 3 4 5 ans : 1 1878011968 1329038170 32 16.

so this method does not work for the case where the number of rotation is larger than array size!!!

error: expected unqualified-id before ‘public’ public class Solution { ^~~~~~

We can optimize the space complexity in the following way:

1. Time complexity: O(n)
2. Space complexity: O(1)

Approach:

    LeftRotation(ar, n, d)  {
         reverse(0, n-1, ar);
         reverse(0, n-d-1, ar);
         reverse(n-d, n-1, ar);
    }

Code:

public static void main(String[] args) {
        int[] ar = {1, 2, 3, 4, 5};
        rotate(ar, ar.length, 4);
        Arrays.stream(ar).forEach(i -> System.out.print(i + " "));
    }

    public static void rotate(int[] ar, int n, int d) {
        reverse(ar, 0, n - 1);
        reverse(ar, 0, n - d - 1);
        reverse(ar, n - d, n - 1);
    }

    private static void reverse(int[] ar, int l, int r) {
        while (l < r) {
            int temp = ar[r];
            ar[r] = ar[l];
            ar[l] = temp;
            l++;
            r--;
        }
    }

great.... i did this but my time complexity was high...

this logic is lit like what was your approach?? how did you found out (i+n-d)%n??

awesome :)

MASHA ALLAH...good logic...simple nd awesome...thanx,4 sharing this..

You didn't actually rotated the array, printing the required answer is not the solution. The rotated array might be of some use later in the actual program and the problem is designed to practice the array rotation. Hope you try to understand.

I do understand d=d%n but in this instance it isn't necessary, question's constraints says 1<d<n

You're over-complicating things with two loops and C arrays in C++.

int n, d;
cin >> n >> d;
vector<int> v((istream_iterator<int>(cin)), istream_iterator<int>());
for (int i = 0; i < n; ++i) cout << v[(i + d) % n] << " ";

splendid :)

please explain the logic thanks in advance

Thanks.Its a smart way to solve the question

as neat as it can get! so satisfying!

but this is just printing data as required . if u check array then no rotation had occured

awesome ^_^

I loved the way you simplify this, but...

cin>>n;
int a[n];

wtf? "a" is a static array, and you set it's size from a variable ¿?

You are just merely printing the result.It might pass all the test cases but the problem to actually shift the array remains unsolved . In your code the array is still the same.

WHat if d is larger than n?

Simply briliiant ;). Thank you!

Thanks bud.

Thanks bro, it mathematical approach I like it. but i thing you done misticks in this code? for (int oldIndex = 0; oldIndex < n; oldIndex++) { int newIndex = (oldIndex + d) % n; rotArray[newIndex] = a[oldIndex]; }

It should be

new index=(old index+n-d)%n;

Hello, thank you for sharing your approach with us. I have a question : Is using auxiliary array allowed? In the problem description we can read the following : "A left rotation operation on an array of size n shifts each of the array's elements unit to the left...". Please note the word shifts. Because of that, I assume that we must operate on only 1 array. Is my assumption wrong?

I saw this was different than the other problems. I put it in the bottom of main, using n, d and a.

Are you using C? There appears to be a bug in the original code in their loop that builds a. This is my fix to their problem:

// bug in original code - only check endptr if we need to do another loop
//      if (a_item_endptr == a_item_str || *a_item_endptr != '\0') { exit(EXIT_FAILURE); }
if (a_item_endptr == a_item_str) { exit(EXIT_FAILURE); }

if (i < (n-1))
{
    if (*a_item_endptr != '\0') { exit(EXIT_FAILURE); }
}
*(a + i) = a_item;