Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Build confidence with an intuition-first walkthrough focused on array fundamentals.
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.
Example 1:
Input: mat = [[0,1],[1,0]], target = [[1,0],[0,1]] Output: true Explanation: We can rotate mat 90 degrees clockwise to make mat equal target.
Example 2:
Input: mat = [[0,1],[1,1]], target = [[1,0],[0,1]] Output: false Explanation: It is impossible to make mat equal to target by rotating mat.
Example 3:
Input: mat = [[0,0,0],[0,1,0],[1,1,1]], target = [[1,1,1],[0,1,0],[0,0,0]] Output: true Explanation: We can rotate mat 90 degrees clockwise two times to make mat equal target.
Constraints:
n == mat.length == target.lengthn == mat[i].length == target[i].length1 <= n <= 10mat[i][j] and target[i][j] are either 0 or 1.Problem summary: 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array
[[0,1],[1,0]] [[1,0],[0,1]]
[[0,1],[1,1]] [[1,0],[0,1]]
[[0,0,0],[0,1,0],[1,1,1]] [[1,1,1],[0,1,0],[0,0,0]]
rotate-image)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1886: Determine Whether Matrix Can Be Obtained By Rotation
class Solution {
public boolean findRotation(int[][] mat, int[][] target) {
int times = 4;
while (times-- > 0) {
if (equals(mat, target)) {
return true;
}
rotate(mat);
}
return false;
}
private void rotate(int[][] matrix) {
int n = matrix.length;
for (int i = 0; i < n / 2; ++i) {
for (int j = i; j < n - 1 - i; ++j) {
int t = matrix[i][j];
matrix[i][j] = matrix[n - j - 1][i];
matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];
matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];
matrix[j][n - i - 1] = t;
}
}
}
private boolean equals(int[][] nums1, int[][] nums2) {
int n = nums1.length;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (nums1[i][j] != nums2[i][j]) {
return false;
}
}
}
return true;
}
}
// Accepted solution for LeetCode #1886: Determine Whether Matrix Can Be Obtained By Rotation
func findRotation(mat [][]int, target [][]int) bool {
n := len(mat)
for k := 0; k < 4; k++ {
g := make([][]int, n)
for i := range g {
g[i] = make([]int, n)
}
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
g[i][j] = mat[j][n-i-1]
}
}
if equals(g, target) {
return true
}
mat = g
}
return false
}
func equals(a, b [][]int) bool {
for i, row := range a {
for j, v := range row {
if v != b[i][j] {
return false
}
}
}
return true
}
# Accepted solution for LeetCode #1886: Determine Whether Matrix Can Be Obtained By Rotation
class Solution:
def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
def rotate(matrix):
n = len(matrix)
for i in range(n // 2):
for j in range(i, n - 1 - i):
t = matrix[i][j]
matrix[i][j] = matrix[n - j - 1][i]
matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1]
matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1]
matrix[j][n - i - 1] = t
for _ in range(4):
if mat == target:
return True
rotate(mat)
return False
// Accepted solution for LeetCode #1886: Determine Whether Matrix Can Be Obtained By Rotation
impl Solution {
pub fn find_rotation(mat: Vec<Vec<i32>>, target: Vec<Vec<i32>>) -> bool {
let n = mat.len();
let mut is_equal = [true; 4];
for i in 0..n {
for j in 0..n {
if is_equal[0] && mat[i][j] != target[i][j] {
is_equal[0] = false;
}
if is_equal[1] && mat[i][j] != target[j][n - 1 - i] {
is_equal[1] = false;
}
if is_equal[2] && mat[i][j] != target[n - 1 - i][n - 1 - j] {
is_equal[2] = false;
}
if is_equal[3] && mat[i][j] != target[n - 1 - j][i] {
is_equal[3] = false;
}
}
}
is_equal.into_iter().any(|&v| v)
}
}
// Accepted solution for LeetCode #1886: Determine Whether Matrix Can Be Obtained By Rotation
function findRotation(mat: number[][], target: number[][]): boolean {
for (let k = 0; k < 4; k++) {
rotate(mat);
if (isEqual(mat, target)) {
return true;
}
}
return false;
}
function isEqual(A: number[][], B: number[][]) {
const n = A.length;
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (A[i][j] !== B[i][j]) {
return false;
}
}
}
return true;
}
function rotate(matrix: number[][]): void {
const n = matrix.length;
for (let i = 0; i < n >> 1; i++) {
for (let j = 0; j < (n + 1) >> 1; j++) {
[
matrix[i][j],
matrix[n - 1 - j][i],
matrix[n - 1 - i][n - 1 - j],
matrix[j][n - 1 - i],
] = [
matrix[n - 1 - j][i],
matrix[n - 1 - i][n - 1 - j],
matrix[j][n - 1 - i],
matrix[i][j],
];
}
}
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.