Rotate Image

mediumFREEMath & GeometryBlind 75

Rotate an n x n 2D matrix 90 degrees clockwise in-place.

Input: matrix, a list of n lists of n integers (the example shows it as rows of comma-separated integers). Modify matrix in place and return nothing; the tests print the rotated matrix afterwards, one row per line with values separated by spaces.

Example

Input

1,2,3
4,5,6
7,8,9

Output

7 4 1
8 5 2
9 6 3

Reasoning

matrix is a square grid with $n = 3$ rows and 3 columns: rows 1,2,3, 4,5,6, 7,8,9. Count rows and columns from 0.
A 90° clockwise turn sends the entry at row $i$ , column $j$ to row $j$ , column $n - 1 - i$ . Here that column is $2 - i$ .
Track the top row: 1 at $(0,0)$ lands at $(0,2)$ , 2 at $(0,1)$ lands at $(1,2)$ , 3 at $(0,2)$ lands at $(2,2)$ . The top row becomes the right column.
Track the left column: 7 at $(2,0)$ lands at $(0,0)$ and 4 at $(1,0)$ lands at $(0,1)$ , so the new top row is 7 4 1. Every other cell follows the same rule, giving 8 5 2 and 9 6 3 below it.
Notice that the four corners trade places in a cycle ( $1 \to 3 \to 9 \to 7 \to 1$ by position), and the centre 5 stays put because $(1,1)$ maps to itself.
The grid itself must hold the rotated values; the printed rows are read from it.

Constraints

1 <= n <= 20
-1000 <= matrix[i][j] <= 1000

More from Blind 75

Alien Dictionaryhard Clone Graphmedium Combination Summedium Word Search IIhard Merge K Sorted Listshard

Concept primer

Background Knowledge

The problem of rotating an $n \times n$ 2D matrix 90 degrees clockwise in-place involves understanding the structure of matrices and how to manipulate them. A matrix is a 2D array of elements, and in this case, we're dealing with a square matrix where the number of rows equals the number of columns ( $n = \text{len}(arr)$ ). Rotating such a matrix involves changing the position of its elements in a way that the first column becomes the first row, the second column becomes the second row, and so on, but in reverse order due to the clockwise rotation.

To approach this problem, it's essential to understand the concept of matrix transpose and how to manipulate indices to achieve the desired rotation. The transpose of a matrix is obtained by interchanging its rows into columns or columns into rows. For a matrix $A$ , its transpose is denoted as $A^T$ . Understanding how to transpose a matrix and then how to reverse each row can help in visualizing the rotation process.

The mathematical concept behind rotating a matrix can be understood by considering the transformation of each element's position. If we have a matrix $A$ with elements $a_{ij}$ , where $i$ is the row index and $j$ is the column index, then after a 90-degree clockwise rotation, the element at position $(i, j)$ moves to position $(j, n-i-1)$ . This transformation gives us a clue on how to approach the problem algorithmically.

Algorithm/Approach

The general approach to solving this type of problem involves a combination of matrix transpose and row reversal. The algorithm pattern can be broken down into two main steps: first, transposing the matrix, and second, reversing each row of the transposed matrix. This approach ensures that the matrix is rotated 90 degrees clockwise in-place, meaning that the rotation is performed without using any additional space that scales with the input size.

Step-by-Step Strategy

To implement the solution:

Transpose the Matrix: Iterate through the matrix and swap elements across the main diagonal (from top-left to bottom-right). This step involves swapping $a_{ij}$ with $a_{ji}$ for all $i$ and $j$ where $i < j$ .
Reverse Each Row: After transposing the matrix, reverse the order of elements in each row. This can be done by using two pointers, one starting from the beginning of the row and one from the end, and swapping the elements at these positions as the pointers move towards each other.

Common Pitfalls

When implementing the solution, watch out for:

Incorrect indexing when transposing the matrix or reversing the rows.
Not handling the case where $n$ is odd correctly, although the approach remains the same.
Using extra space that scales with the input size, which violates the in-place requirement.

Time & Space Complexity

The expected time complexity for this problem is $O(n^2)$ , where $n$ is the number of rows (or columns) of the matrix, because we are potentially visiting each element twice: once for transposing and once for reversing. The space complexity should be $O(1)$ , excluding the space needed for the output, since we are performing the rotation in-place and not using any additional space that scales with the input size.

solution.py

Python 3.13

Test results