【Leetcode】Rotate Image

You are given an n x n 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Follow up:

Could you do this in-place?
——————————————————————
Question is not hard at all. All you need to do is to find the pattern behind the rule, which is a[i,j] -> a[j,n-i-1] where n is the length of the matrix.

Thus, I wrote directly on Leetcode and accepted my solution in quick.

public class RotateImage {
public static void main(String args[]){
RotateImage ri = new RotateImage();
int[][] mat = {{1,2,3},{4,5,6},{7,8,9}};
ri.rotate(mat);
prinf(mat);
}

private static void prinf(int[][] input){
int l = input.length;
for(int p=0;p<l;p++){
for(int q=0;q<l;q++)
System.out.print(input[p][q]);
System.out.println();}
}

public void rotate(int[][] matrix) {
int len = matrix.length;
int[][] tmp = new int[len][len];
for(int i=0;i<len;i++){
for(int j=0;j<len;j++){
tmp[i][j]=matrix[i][j];
}
}

for(int i=0;i<len;i++)
for(int j=0;j<len;j++){
matrix[j][len-i-1] = tmp[i][j];
}

}
}

well.. but the question wish us to finish in place. I can't help searching the best answer and I wound up with a great one-line python solution that utterly shock me.

Here we go:

class Solution(object):
def rotate(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: void Do not return anything, modify matrix in-place instead.
"""
matrix[::] = zip(*matrix[::-1])

Consider the following two-dimensional list:

original = [[1, 2],
[3, 4]]

Lets break it down step by step:

>>> original[::-1]   # elements of original are reversed
[[3, 4], [1, 2]]

This list is passed into

zip()

using argument
unpacking, so the

zip

call
ends up being the equivalent of this:

zip([3, 4],
[1, 2])
#    ^  ^----column 2
#    |-------column 1
# returns [(3, 1), (4, 2)], which is a original rotated clockwise

Hopefully the comments make it clear what

zip

does,
it will group elements from each input iterable based on index, or in other words it groups the columns.