Home/ Questions/Q 16979
Next
In Process

askthedev.com Latest Questions

Asked: 2024-09-27T12:44:54+05:30 In:

How to Rotate a Matrix Clockwise by Layers in Python?

I’ve been tinkering with matrices lately, and I stumbled upon a fun challenge involving rotating a matrix clockwise. It got me pretty intrigued, and I wanted to share a problem inspired by it and see what kind of creative solutions we can come up with!

Imagine you have a 2D array (or matrix) filled with integers. The challenge is to rotate the matrix 90 degrees clockwise. For instance, if your input is:

“`
1 2 3
4 5 6
7 8 9
“`

The output after rotation would look like this:

“`
7 4 1
8 5 2
9 6 3
“`

Pretty straightforward, right? But here’s the additional twist: instead of just rotating the whole matrix at once, let’s make it a step-by-step process!

Here’s what I’m thinking: We should first extract each “layer” of the matrix and rotate that layer individually before combining everything back together. Like peeling an onion, where the outer layer gets rotated first, followed by the inner layers. It adds a bit of complexity and makes the problem a bit more interesting.

For example, consider this input:

“`
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
“`

In this scenario, the outer layer (1, 2, 3, 4, 8, 12, 16, 13, 9, 5) would rotate clockwise to become (13, 1, 5, 9, 16, 12, 8, 4, 3, 2). Then, you’d handle the next layer inside, which includes (6, 7, 11, 10), rotating it similarly.

So, how would you approach this? What algorithms or techniques would you use to efficiently handle the rotation of the layers? And, more importantly, what would your output be like, maintaining the final structure of the matrix? I’d love to see your thought processes and solutions! Let’s see who can come up with the most efficient and clever way to whip this matrix into shape!

Share

    Leave an answer

    You must login to add an answer.

    Need An Account,

    2 Answers

    1. To tackle the challenge of rotating a matrix 90 degrees clockwise in a step-by-step layer-by-layer manner, we can break the problem down into manageable parts. First, we extract the outer layer of the matrix and store it in a list. For a given matrix, we can determine the outer layer by traversing the top row from left to right, the right column from top to bottom, the bottom row from right to left, and the left column from bottom to top. Once we have extracted the outer layer, we will rotate this list by moving the last element to the front, effectively shifting all elements clockwise. After updating the outer layer, we insert it back into its original positions in the matrix. We can repeat this process for each inner layer of the matrix until we have transformed the entire matrix.

      Here is a Python implementation that demonstrates this approach:

      
def rotate_layer(matrix, layer):
    n = len(matrix) - 1
    # Extract the layer
    elements = []
    for i in range(layer, n - layer + 1):
        elements.append(matrix[layer][i])  # top row
    for i in range(layer + 1, n - layer):
        elements.append(matrix[i][n - layer])  # right column
    for i in range(n - layer, layer - 1, -1):
        elements.append(matrix[n - layer][i])  # bottom row
    for i in range(n - layer - 1, layer, -1):
        elements.append(matrix[i][layer])  # left column

    # Rotate the layer
    elements = [elements[-1]] + elements[:-1]

    # Place back into the matrix
    idx = 0
    for i in range(layer, n - layer + 1):
        matrix[layer][i] = elements[idx]
        idx += 1
    for i in range(layer + 1, n - layer):
        matrix[i][n - layer] = elements[idx]
        idx += 1
    for i in range(n - layer, layer - 1, -1):
        matrix[n - layer][i] = elements[idx]
        idx += 1
    for i in range(n - layer - 1, layer, -1):
        matrix[i][layer] = elements[idx]
        idx += 1

def rotate_matrix(matrix):
    layers = (len(matrix) + 1) // 2
    for layer in range(layers):
        rotate_layer(matrix, layer)

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
]

rotate_matrix(matrix)
for row in matrix:
    print(row)  # Output the rotated matrix
  

    2. function rotateMatrixClockwise(matrix) {
    if (matrix.length === 0 || matrix[0].length === 0) return matrix;

    const layers = Math.ceil(Math.min(matrix.length, matrix[0].length) / 2);

    for (let layer = 0; layer < layers; layer++) {
        const first = layer;
        const last = matrix.length - 1 - layer;

        // Store the values of the outer layer
        const topRow = [];
        for (let i = first; i <= last; i++) {
            topRow.push(matrix[first][i]);
        }

        const rightCol = [];
        for (let i = first + 1; i <= last; i++) {
            rightCol.push(matrix[i][last]);
        }

        const bottomRow = [];
        for (let i = last; i >= first; i--) {
            bottomRow.push(matrix[last][i]);
        }

        const leftCol = [];
        for (let i = last - 1; i >= first + 1; i--) {
            leftCol.push(matrix[i][first]);
        }

        // Rotate the outer layer
        const rotatedLayer = [
            leftCol[leftCol.length - 1], ...topRow, rightCol[0], bottomRow[0], 
            bottomRow.slice(1), rightCol.slice(1), leftCol.slice(0, leftCol.length - 1)
        ].flat();

        // Mapping back the rotated values into the matrix
        let index = 0;

        // Top row
        for (let i = first; i <= last; i++) {
            matrix[first][i] = rotatedLayer[index++];
        }

        // Right column
        for (let i = first + 1; i <= last; i++) {
            matrix[i][last] = rotatedLayer[index++];
        }

        // Bottom row
        for (let i = last; i >= first; i--) {
            matrix[last][i] = rotatedLayer[index++];
        }

        // Left column
        for (let i = last - 1; i >= first + 1; i--) {
            matrix[i][first] = rotatedLayer[index++];
        }
    }

    return matrix;
}

// Example usage:
const matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16]
];

console.log(rotateMatrixClockwise(matrix));

    Related Questions