Determine Whether Matrix Can Be Obtained By Rotation

Determine Whether Matrix Can Be Obtained By Rotation - Problem

Array Matrix Easy

Given two n x n binary matrices mat and target, return true if it is possible to make mat equal to target by rotating mat in 90-degree increments, or false otherwise.

A 90-degree rotation means rotating the matrix clockwise by 90 degrees. You can perform this rotation 0, 1, 2, or 3 times to check if any of the resulting matrices match the target.

Input & Output

Example 1 — Basic Rotation Match

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

› Output: true

💡 Note: Rotating mat 90° clockwise gives [[1,0],[0,1]] which equals target. The top-left 0 moves to top-right, top-right 1 moves to bottom-right, etc.

Example 2 — No Rotation Match

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

› Output: false

💡 Note: None of the 4 rotations (0°, 90°, 180°, 270°) of mat equals target. mat has two 1s but target has them in different positions that can't be achieved by rotation.

Example 3 — 180° Rotation Match

$ 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 target. The bottom row [1,1,1] becomes the top row, and the top row [0,0,0] becomes the bottom row.

Constraints

n == mat.length == mat[i].length == target.length == target[i].length
1 ≤ n ≤ 10
mat[i][j] and target[i][j] are either 0 or 1

Visualization

Tap to expand

Asked in

f Facebook 15 G Google 8 Apple 6

The key insight is that there are only 4 possible rotations (0°, 90°, 180°, 270°) to check. The optimal approach calculates rotated positions using mathematical formulas without storing intermediate matrices. Time: O(n²), Space: O(1).

Common Approaches

✓ Generate All Rotations

⏱️ Time: O(n²) Space: O(n²)

Create all four possible rotated versions of the matrix (0°, 90°, 180°, 270°) and compare each one with the target matrix. This approach is straightforward but uses extra space to store rotated matrices.

In-Place Rotation Check

⏱️ Time: O(n²) Space: O(1)

Instead of generating all rotations, we directly compare matrix elements by calculating where each element would be after rotation. This saves space by avoiding intermediate matrix storage.

Generate All Rotations — Algorithm Steps

Create the original matrix (0° rotation)
Generate 90°, 180°, and 270° rotations
Compare each rotation with target matrix
Return true if any matches, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with mat at 0° rotation

Generate Rotations

Create 90°, 180°, 270° rotations

Compare Each

Check if any rotation equals target

Code -

solution.c — C

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

// Parse a JSON matrix from string
int** parseMatrix(char* str, int* n) {
    // Count dimensions first
    int rows = 0, cols = 0;
    char* temp = str;
    
    // Skip initial '['
    while (*temp && *temp != '[') temp++;
    if (*temp) temp++;
    
    // Count rows and columns
    while (*temp) {
        if (*temp == '[') {
            rows++;
            temp++;
            int currentCols = 0;
            while (*temp && *temp != ']') {
                if (isdigit(*temp)) {
                    currentCols++;
                    while (isdigit(*temp)) temp++;
                } else {
                    temp++;
                }
            }
            if (cols == 0) cols = currentCols;
        } else {
            temp++;
        }
    }
    
    *n = rows;
    
    // Allocate matrix
    int** matrix = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
    }
    
    // Parse values
    temp = str;
    while (*temp && *temp != '[') temp++;
    if (*temp) temp++;
    
    int row = 0, col = 0;
    while (*temp && row < rows) {
        if (*temp == '[') {
            temp++;
            col = 0;
            while (*temp && *temp != ']' && col < cols) {
                if (isdigit(*temp)) {
                    matrix[row][col] = *temp - '0';
                    col++;
                    while (isdigit(*temp)) temp++;
                } else {
                    temp++;
                }
            }
            row++;
        } else {
            temp++;
        }
    }
    
    return matrix;
}

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 i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            rotated[j][n - 1 - i] = matrix[i][j];
        }
    }
    return rotated;
}

void freeMatrix(int** matrix, int n) {
    for (int i = 0; i < n; i++) {
        free(matrix[i]);
    }
    free(matrix);
}

bool solution(int** mat, int** target, int n) {
    // Create copy of original matrix
    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];
        }
    }
    
    // Check all 4 rotations
    for (int rotation = 0; rotation < 4; rotation++) {
        if (matricesEqual(current, target, n)) {
            freeMatrix(current, n);
            return true;
        }
        int** temp = rotate90(current, n);
        freeMatrix(current, n);
        current = temp;
    }
    
    freeMatrix(current, n);
    return false;
}

int main() {
    char line1[10000], line2[10000];
    
    // Read two lines
    if (fgets(line1, sizeof(line1), stdin) == NULL) return 1;
    if (fgets(line2, sizeof(line2), stdin) == NULL) return 1;
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int n1, n2;
    int** mat = parseMatrix(line1, &n1);
    int** target = parseMatrix(line2, &n2);
    
    bool result = solution(mat, target, n1);
    printf("%s\n", result ? "true" : "false");
    
    freeMatrix(mat, n1);
    freeMatrix(target, n2);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

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

⚠ Quadratic Growth

Space Complexity

O(n²)

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

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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