feat: add solutions to lc problem: No.1886

No.1886.Determine Whether Matrix Can Be Obtained By Rotation

Author: yanglbme

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README.md

@@ -91,6 +91,16 @@ class Solution:
         return False
 ```
 
+```python
+class Solution:
+    def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
+        for _ in range(4):
+            mat = [list(col) for col in zip(*mat[::-1])]
+            if mat == target:
+                return True
+        return False
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -135,6 +145,95 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean findRotation(int[][] mat, int[][] target) {
+        int n = mat.length;
+        for (int k = 0; k < 4; ++k) {
+            int[][] g = new int[n][n];
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    g[i][j] = mat[j][n - i - 1];
+                }
+            }
+            if (equals(g, target)) {
+                return true;
+            }
+            mat = g;
+        }
+        return false;
+    }
+
+    private boolean equals(int[][] a, int[][] b) {
+        int n = a.length;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (a[i][j] != b[i][j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {
+        int n = mat.size();
+        for (int k = 0; k < 4; ++k)
+        {
+            vector<vector<int>> g(n, vector<int>(n));
+            for (int i = 0; i < n; ++i)
+                for (int j = 0; j < n; ++j)
+                    g[i][j] = mat[j][n - i - 1];
+            if (g == target) return true;
+            mat = g;
+        }
+        return false;
+    }
+};
+```
+
+### **Go**
+
+```go
+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
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/README_EN.md

@@ -66,6 +66,16 @@ class Solution:
         return False
 ```
 
+```python
+class Solution:
+    def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
+        for _ in range(4):
+            mat = [list(col) for col in zip(*mat[::-1])]
+            if mat == target:
+                return True
+        return False
+```
+
 ### **Java**
 
 ```java
@@ -108,6 +118,95 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public boolean findRotation(int[][] mat, int[][] target) {
+        int n = mat.length;
+        for (int k = 0; k < 4; ++k) {
+            int[][] g = new int[n][n];
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    g[i][j] = mat[j][n - i - 1];
+                }
+            }
+            if (equals(g, target)) {
+                return true;
+            }
+            mat = g;
+        }
+        return false;
+    }
+
+    private boolean equals(int[][] a, int[][] b) {
+        int n = a.length;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (a[i][j] != b[i][j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {
+        int n = mat.size();
+        for (int k = 0; k < 4; ++k)
+        {
+            vector<vector<int>> g(n, vector<int>(n));
+            for (int i = 0; i < n; ++i)
+                for (int j = 0; j < n; ++j)
+                    g[i][j] = mat[j][n - i - 1];
+            if (g == target) return true;
+            mat = g;
+        }
+        return false;
+    }
+};
+```
+
+### **Go**
+
+```go
+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
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {
+        int n = mat.size();
+        for (int k = 0; k < 4; ++k)
+        {
+            vector<vector<int>> g(n, vector<int>(n));
+            for (int i = 0; i < n; ++i)
+                for (int j = 0; j < n; ++j)
+                    g[i][j] = mat[j][n - i - 1];
+            if (g == target) return true;
+            mat = g;
+        }
+        return false;
+    }
+};

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.go

@@ -0,0 +1,30 @@
+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
+}

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.java

@@ -1,33 +1,26 @@
 class Solution {
     public boolean findRotation(int[][] mat, int[][] target) {
-        int times = 4;
-        while (times-- > 0) {
-            if (equals(mat, target)) {
+        int n = mat.length;
+        for (int k = 0; k < 4; ++k) {
+            int[][] g = new int[n][n];
+            for (int i = 0; i < n; ++i) {
+                for (int j = 0; j < n; ++j) {
+                    g[i][j] = mat[j][n - i - 1];
+                }
+            }
+            if (equals(g, target)) {
                 return true;
             }
-            rotate(mat);
+            mat = g;
         }
         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;
+
+    private boolean equals(int[][] a, int[][] b) {
+        int n = a.length;
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < n; ++j) {
-                if (nums1[i][j] != nums2[i][j]) {
+                if (a[i][j] != b[i][j]) {
                     return false;
                 }
             }

solution/1800-1899/1886.Determine Whether Matrix Can Be Obtained By Rotation/Solution.py

@@ -1,17 +1,7 @@
 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):
+            mat = [list(col) for col in zip(*mat[::-1])]
             if mat == target:
                 return True
-            rotate(mat)
         return False

solution/CONTEST_README.md

@@ -5,11 +5,11 @@
 
 ## 段位与荣誉勋章
 
-竞赛排名根据 竞赛积分（周赛和双周赛）进行计算，注册新用户的基础分值为 1500 分，在竞赛积分 ≥1600 的用户中，根据比例 5%, 20%, 75% 设定三档段位，段位每周比赛结束后计算一次。
+竞赛排名根据竞赛积分（周赛和双周赛）进行计算，注册新用户的基础分值为 1500 分，在竞赛积分 ≥1600 的用户中，根据比例 5%, 20%, 75% 设定三档段位，段位每周比赛结束后计算一次。
 
 如果竞赛积分处于段位的临界值，在每周比赛结束重新计算后会出现段位升级或降级的情况。段位升级或降级后会自动替换对应的荣誉勋章。
 
-| 段位  | 比例   | 段位名   | 国服分数线    | 勋章展示                                                                    |
+| 段位  | 比例   | 段位名   | 国服分数线    | 勋章                                                                    |
 | ----- | ------ | -------- | --------- | --------------------------------------------------------------------------- |
 | LV3 | 5%  | Guardian | &ge;2217.22 | <p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/images/Guardian.gif" style="width: 80px;" /></p> |
 | LV2 | 20% | Knight   | &ge;1862.81 | <p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/images/Knight.gif" style="width: 80px;" /></p>   |

solution/contest.py

@@ -121,7 +121,7 @@ def generate_contest_list():
 
 如果竞赛积分处于段位的临界值，在每周比赛结束重新计算后会出现段位升级或降级的情况。段位升级或降级后会自动替换对应的荣誉勋章。
 
-| 段位  | 比例   | 段位名   | 国服分数线    | 勋章展示                                                                    |
+| 段位  | 比例   | 段位名   | 国服分数线    | 勋章                                                                    |
 | ----- | ------ | -------- | --------- | --------------------------------------------------------------------------- |
 | LV3 | 5%  | Guardian | &ge;2217.22 | <p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/images/Guardian.gif" style="width: 80px;" /></p> |
 | LV2 | 20% | Knight   | &ge;1862.81 | <p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/images/Knight.gif" style="width: 80px;" /></p>   |