# rotate array rotateLeft3

Hi,

I am working  below challenge

http://codingbat.com/prob/p185139

``````public int[] rotateLeft3(int[] nums) {
int num1=nums[0];
int num2=nums[1];
int num3=nums[2]

}
``````

i kind of started but not sure on the approach to follow. Please advise
LVL 7
###### Who is Participating?

x

Commented:
Looks closely at the first example:
rotateLeft3({1, 2, 3}) → {2, 3, 1}

to see how the numbers move.  Each goes one left and the first number goes to the end.

The solution ozo posted is perfectly fine here.  But if you want to think about this problem a bit more you might want to consider a solution like this which works for any length array (>= 1):

``````public int[] rotateLeft3(int[] nums) {
int len = nums.length ;
int first = nums[0] ;
for (int i = 0 ; i < len-1 ; i++) {
nums[i] = nums[i+1] ;
}
nums[len-1] = first ;
return nums ;
}
``````

Can you see how it moves everything left and then moves the first value to the end?

Doug
0

Commented:
int array[]={nums[1],nums[2],nums[0]};
return array;
0

Author Commented:
rotate left means what. Is it is not same as reversing?
i thought it shoud be like

int array[]={nums[2],nums[1],nums[0]};
return array;

0

Commented:
The word rotate is being used in this sense: http://en.wikipedia.org/wiki/Circular_shift#Example
0

Associate Software DeveloperCommented:
The following solution does this without any extra variables :)
``````public int[] rotateLeft3(int[] nums) {
nums[0]^=nums[1];
nums[1]^=nums[0];
nums[0]^=nums[1];
nums[1]^=nums[2];
nums[2]^=nums[1];
nums[1]^=nums[2];
return nums;
}
``````

Let me try to explain how it works.
We can rotate the whole array by two steps
1. swap nums[0] and nums[1]
2. swap nums[1] and nums[2]

If you can see the XOR swap algorithm, two numbers a and b can be swapped by the following
``````a ^= b;
b ^= a;
a ^= b;
``````
That is exactly what I've done in first three lines to swap first two elements, similarly last three lines are swapping last two elements.
0

Author Commented:
``````nums[0]^=nums[1];
nums[1]^=nums[0];
nums[0]^=nums[1];
nums[1]^=nums[2];
nums[2]^=nums[1];
nums[1]^=nums[2];
``````

can you please elaborate on this.

How ^ works. I have not used that much earlier.

``````public int[] rotateLeft3(int[] nums) {
int len = nums.length ;
int first = nums[0] ;
for (int i = 0 ; i < len-1 ; i++) {
nums[i] = nums[i+1] ;
}
nums[len-1] = first ;
return nums ;
}
``````
above also passed all tests
0

Commented:
0

Author Commented:
basicaly it is circular movement(first is kept at last and other than placed at index subtracted by 1 to orignial) right?
0

Commented:
Yes, assuming that indexes are numbered left to right.
0

Commented:
The XOR (^) solution is clever - but not one you should be focusing on when learning the basics of the language.  You could go for many many years as a professional Java developer and never see that pattern again.

You should focus on loops, variable assignments etc. over the behavior of binary operators like XOR.  I think Nadia was just having some fun and pointing out there are many possible solutions here.

Did you figure out how this works and why it would work for rotating arrays of any length >= 1?

``````public int[] rotateLeft3(int[] nums) {
int len = nums.length ;
int first = nums[0] ;
for (int i = 0 ; i < len-1 ; i++) {
nums[i] = nums[i+1] ;
}
nums[len-1] = first ;
return nums ;
}
``````

Doug
0

Commented:
http://en.wikipedia.org/wiki/XOR_swap_algorithm#Reasons_for_avoidance_in_practice explains several reasons not to use the xor solution.
An additional reason in this application is that it uses 3*(n-1) operations instead of n+1 operations using a temporary.
0

Author Commented:
Did you figure out how this works and why it would work for rotating arrays of any length >= 1?

yes I think  it is circular movement(first is kept at last and other than placed at index subtracted by 1 to orignial) right

``````public int[] rotateLeft3(int[] nums) {
int len = nums.length ;//find lengh of nums array
int first = nums[0] ;assign fist element of arrya to first int variable
for (int i = 0 ; i < len-1 ; i++) {//loop through till the end of the array lenth
nums[i] = nums[i+1] ;//assign right hand side element to left hand side element except first i think??
}
nums[len-1] = first ;//assign first to last elemt now
return nums ; return the nums array which is modified
}
``````

0

Commented:
Yep that's it exactly.

For these problems it's often good to solve the specific challenge they give you and also think about the wider set of similar problems.

Sounds like you've mastered this one.

Doug
0
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.