Determine Whether Matrix Can Be Obtained By Rotation

Determine Whether Matrix Can Be Obtained By Rotation - Problem

Array Matrix Easy

Imagine you have two n × n binary matrices (containing only 0s and 1s) - one called mat and another called target. Your task is to determine whether you can transform mat into target by rotating it in 90-degree increments (clockwise).

Think of it like rotating a game board or a puzzle piece - you can rotate it 0°, 90°, 180°, or 270° to see if any of these rotations match your target pattern.

Goal: Return true if any rotation of mat equals target, otherwise return false.

Example: If mat = [[0,1],[1,0]] and target = [[1,0],[0,1]], rotating mat by 90° clockwise gives us exactly the target!

Input & Output

example_1.py — Basic Rotation Match

$ Input: mat = [[0,1],[1,0]], target = [[1,0],[0,1]]

› Output: true

💡 Note: Rotating mat 90° clockwise transforms [0,1],[1,0] to [1,0],[0,1] which exactly matches target

example_2.py — No Possible Rotation

$ Input: mat = [[0,1],[1,1]], target = [[1,0],[0,1]]

› Output: false

💡 Note: No rotation of mat can produce target. Mat has three 1s, but target has only two 1s

example_3.py — Identity Matrix

$ Input: mat = [[0,0,0],[0,1,0],[1,1,1]], target = [[1,1,1],[0,1,0],[0,0,0]]

› Output: true

💡 Note: Rotating mat 180° gives us the target matrix

Constraints

n == mat.length == mat[i].length == target.length == target[i].length
1 ≤ n ≤ 20
mat[i][j] and target[i][j] are either 0 or 1
Note: Only 90-degree clockwise rotations are allowed

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Recognize that we only need to check 4 possible orientations

Mathematical Mapping

Use formulas to map original positions to rotated positions

Direct Comparison

Compare elements directly without creating new matrices

Early Exit

Return true immediately when a match is found

Key Takeaway

🎯 Key Insight: We can check all 4 rotations mathematically in O(1) space by mapping coordinates directly, making this an elegant and efficient solution.

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses direct rotation mapping without storing intermediate matrices. For each of the 4 possible rotations (0°, 90°, 180°, 270°), we calculate where each element would end up using mathematical formulas and compare directly with the target. This achieves O(n²) time and O(1) space complexity with early exit optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Rotations	O(n²)	O(n²)	Generate all 4 possible rotations and compare each with target
Direct Rotation Check (Optimal)	O(n²)	O(1)	Check rotations on-the-fly without storing intermediate matrices

Generate All Rotations — Algorithm Steps

Start with the original matrix (0° rotation)
Generate 90° clockwise rotation by transposing and reversing each row
Generate 180° rotation by reversing both rows and columns
Generate 270° rotation by transposing and reversing each column
Compare each rotation with the target matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with the input matrix mat

90° Rotation

Rotate clockwise by 90 degrees and compare with target

180° Rotation

Continue rotating and comparing

270° Rotation

Final rotation check

Code -

solution.c — C

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

bool matricesEqual(int** m1, int** m2, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (m1[i][j] != m2[i][j]) return false;
        }
    }
    return true;
}

int** rotate90(int** matrix, int n) {
    int** rotated = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        rotated[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            rotated[j][n - 1 - i] = matrix[i][j];
        }
    }
    return rotated;
}

bool findRotation(int** mat, int matSize, int* matColSize, int** target, int targetSize, int* targetColSize) {
    int n = matSize;
    int** current = (int**)malloc(n * sizeof(int*));
    
    for (int i = 0; i < n; i++) {
        current[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            current[i][j] = mat[i][j];
        }
    }
    
    for (int rotations = 0; rotations < 4; rotations++) {
        if (matricesEqual(current, target, n)) return true;
        int** temp = rotate90(current, n);
        
        // Free previous current matrix
        for (int i = 0; i < n; i++) free(current[i]);
        free(current);
        
        current = temp;
    }
    
    // Free final current matrix
    for (int i = 0; i < n; i++) free(current[i]);
    free(current);
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We generate 4 rotations, each taking O(n²) time, and compare each with target in O(n²) time

⚠ Quadratic Growth

Space Complexity

O(n²)

We store rotated matrices, each requiring O(n²) space

⚠ Quadratic Space

47.2K Views

Medium 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Generate All Rotations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler