Skip to content
The Chat Archive
grok-3-mini-beta· xAI LMArena Human Preference 140K

Given a matrix, rotate it 90 degrees clockwise in-place.

  1. User

    Given a matrix, rotate it 90 degrees clockwise in-place.

  2. Assistant

    Rotating a matrix 90 degrees clockwise in-place is a common problem in computer science, often encountered in coding interviews. This operation requires modifying the original matrix directly without creating a new one.

    Key Concepts:

    • In-place modification: We will swap elements within the same matrix to achieve the rotation.
    • Square matrix assumption: This method works for square matrices (e.g., n x n). If the matrix isn't square, rotation in-place isn't straightforward.
    • Steps involved:
      1. Transpose the matrix: Swap elements across the main diagonal (i.e., swap matrix[i][j] with matrix[j][i]).
      2. Reverse each row: After transposing, reverse the elements in each row to get the clockwise rotation.

    For example:

    • Original matrix:
      [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
      ]
      
    • After transpose:
      [
        [1, 4, 7],
        [2, 5, 8],
        [3, 6, 9]
      ]
      
    • After reversing each row:
      [
        [7, 4, 1],
        [8, 5, 2],
        [9, 6, 3]
      ]
      

    Python Implementation:

    Here's the code to perform the rotation:

    def rotate(matrix):
        if not matrix:  # Handle empty matrix
            return
        
        n = len(matrix)  # Size of the matrix (assuming it's n x n)
        
        # Step 1: Transpose the matrix
        for i in range(n):
            for j in range(i, n):  # Only go up to i to avoid redundant swaps
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        
        # Step 2: Reverse each row
        for i in range(n):
            matrix[i].reverse()  # Reverse the i-th row
    
    # Example Usage:
    matrix = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    
    print("Original Matrix:")
    for row in matrix:
        print(row)
    
    rotate(matrix)
    
    print("\nRotated Matrix (90 degrees clockwise):")
    for row in matrix:
        print(row)
    # Output:
    # Original Matrix:
    # [1, 2, 3]
    # [4, 5, 6]
    # [7, 8, 9]
    #
    # Rotated Matrix (90 degrees clockwise):
    # [7, 4, 1]
    # [8, 5, 2]
    # [9, 6, 3]
    

    Explanation of the Code:

    • Transpose Step: We loop through the upper triangle of the matrix (i from 0 to n-1, j from i to n-1) and swap elements.
    • Reverse Step: For each row, we use Python's list.reverse() method to reverse the elements in that row.
    • Time Complexity: O(n^2), where n is the number of rows (or columns) in the matrix, as we visit each element a constant number of times.
    • Space Complexity: O(1), since we're modifying the matrix in-place without using extra space proportional to the input size.

    Notes:

    • This solution assumes the input is a valid square matrix. If you're dealing with non-square matrices, you'd need to handle it differently (e.g., by creating a new matrix).
    • Edge cases:
      • A 1x1 matrix will remain unchanged.
      • An empty matrix (e.g., []) will do nothing.

    If you have any additional constraints or need variations (e.g., counter-clockwise rotation), let me know!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.