Rotate Image - Practice Coding Problems

Rotate Image - Problem

🔄 Rotate Image - Transform Your Matrix Like a Pro!

Imagine you're working with digital image processing, and you need to rotate a square image by 90 degrees clockwise. You're given an n × n 2D matrix representing an image, where each cell contains a pixel value.

Your challenge? Rotate the entire image in-place - meaning you must modify the original matrix directly without using any additional 2D matrices. This constraint makes the problem particularly interesting as you need to be clever about how you move elements around!

Example: If you have a 3×3 matrix representing an image, after rotation:

[1,2,3]    [7,4,1]
[4,5,6] -> [8,5,2]
[7,8,9]    [9,6,3]

Notice how the first row becomes the last column, the second row becomes the middle column, and so on. Your task is to implement this transformation efficiently and elegantly!

Input & Output

example_1.py — Basic 3×3 Matrix

$ Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]

› Output: [[7,4,1],[8,5,2],[9,6,3]]

💡 Note: After 90° clockwise rotation, the first row [1,2,3] becomes the last column [1,2,3], the second row [4,5,6] becomes the middle column [4,5,6], and the third row [7,8,9] becomes the first column [7,8,9]. The result is the matrix rotated 90° clockwise.

example_2.py — 4×4 Matrix

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

› Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

💡 Note: For a 4×4 matrix, we have two layers to rotate. The outer layer elements move in cycles of 4, and the inner 2×2 layer also rotates. Each element follows the pattern: position (i,j) → (j, n-1-i).

example_3.py — Single Element

$ Input: matrix = [[1]]

› Output: [[1]]

💡 Note: A 1×1 matrix remains unchanged after rotation since there's only one element. This is a simple edge case that our algorithm should handle correctly.

Visualization

Tap to expand

Understanding the Visualization

Identify Layers

An n×n matrix has n/2 concentric layers. The outermost layer forms the border, and we work inward.

Process Each Layer

For each layer, we identify the positions that need to rotate and group them into 4-element cycles.

4-Element Rotation

For each group of 4 positions, we save one element temporarily and rotate the other 3 in sequence.

Complete the Cycle

Place the saved element in its final position, completing the 4-element clockwise rotation.

Key Takeaway

🎯 Key Insight: By treating the matrix as concentric rings and rotating 4 elements at a time, we achieve optimal in-place rotation with just one temporary variable per cycle!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We still need to process each of the n² elements exactly once

⚠ Quadratic Growth

Space Complexity

O(1)

Only use a constant amount of extra space for temporary variables

✓ Linear Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 20
-1000 ≤ matrix[i][j] ≤ 1000
Must be solved in-place with O(1) extra space

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 28 Apple 24

The optimal solution uses layer-by-layer rotation with 4-element cycles. Instead of moving elements one by one, we rotate groups of 4 elements simultaneously in each concentric layer, achieving O(1) space complexity while maintaining O(n²) time complexity. The key insight is treating the matrix as concentric rings and performing cyclic swaps.

Common Approaches

Approach	Time	Space	Notes
✓ Layer-by-Layer Rotation (Optimal In-Place)	O(n²)	O(1)	Rotate matrix in concentric layers using 4-element cycles

Layer-by-Layer Rotation (Optimal In-Place) — Algorithm Steps

Process matrix in concentric layers (rings)
For each layer, iterate through positions that need rotation
For each position, save the top element temporarily
Rotate 4 elements in a cycle: left→top, bottom→left, right→bottom, top→right
Move to inner layers until reaching the center

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Layers

Matrix has concentric layers like onion rings

Process Outer Layer

Rotate elements in groups of 4

4-Element Cycle

top → right → bottom → left → top

Move to Inner Layer

Repeat for inner layers until center

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

void rotate(int** matrix, int matrixSize, int* matrixColSize) {
    // Rotate matrix 90 degrees clockwise in-place using layer-by-layer approach
    int n = matrixSize;
    
    // Process each layer (ring) from outside to inside
    for (int layer = 0; layer < n / 2; layer++) {
        int first = layer;
        int last = n - 1 - layer;
        
        // Rotate elements in current layer
        for (int i = first; i < last; i++) {
            int offset = i - first;
            
            // Save top element
            int top = matrix[first][i];
            
            // left -> top
            matrix[first][i] = matrix[last - offset][first];
            
            // bottom -> left
            matrix[last - offset][first] = matrix[last][last - offset];
            
            // right -> bottom
            matrix[last][last - offset] = matrix[i][last];
            
            // top -> right
            matrix[i][last] = top;
        }
    }
}

int main() {
    int n = 3;
    int** matrix = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        matrix[i] = (int*)malloc(n * sizeof(int));
    }
    
    int values[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = values[i][j];
        }
    }
    
    int* colSizes = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) colSizes[i] = n;
    
    rotate(matrix, n, colSizes);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We still need to process each of the n² elements exactly once

⚠ Quadratic Growth

Space Complexity

O(1)

Only use a constant amount of extra space for temporary variables

✓ Linear Space

Constraints

n == matrix.length == matrix[i].length
1 ≤ n ≤ 20
-1000 ≤ matrix[i][j] ≤ 1000
Must be solved in-place with O(1) extra space

52.0K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🔄 Rotate Image - Transform Your Matrix Like a Pro!

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Layer-by-Layer Rotation (Optimal In-Place) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler