feat: add solutions to lc problem: No.1752

No.1752.Check if Array Is Sorted and Rotated

Author: yanglbme

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README.md

@@ -55,22 +55,75 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：一次遍历**
+
+要满足题目要求，那么数组 `nums` 中最多只能存在一个元素，其值大于下一个元素，即 `nums[i] > nums[i + 1]`。如果存在多个这样的元素，那么数组 `nums` 无法通过轮转得到。
+
+注意，数组 `nums` 最后一个元素的下一个元素是数组 `nums` 的第一个元素。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def check(self, nums: List[int]) -> bool:
+        n = len(nums)
+        return sum(v > nums[(i + 1) % n] for i, v in enumerate(nums)) <= 1
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean check(int[] nums) {
+        int n = nums.length;
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            if (nums[i] > nums[(i + 1) % n]) {
+                ++cnt;
+            }
+        }
+        return cnt <= 1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool check(vector<int>& nums) {
+        int n = nums.size();
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            cnt += nums[i] > (nums[(i + 1) % n]);
+        }
+        return cnt <= 1;
+    }
+};
+```
 
+### **Go**
+
+```go
+func check(nums []int) bool {
+	n := len(nums)
+	cnt := 0
+	for i, v := range nums {
+		if v > nums[(i+1)%n] {
+			cnt++
+		}
+	}
+	return cnt <= 1
+}
 ```
 
 ### **...**

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/README_EN.md

@@ -52,13 +52,58 @@ You can rotate the array by x = 0 positions (i.e. no rotation) to make nums.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def check(self, nums: List[int]) -> bool:
+        n = len(nums)
+        return sum(v > nums[(i + 1) % n] for i, v in enumerate(nums)) <= 1
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean check(int[] nums) {
+        int n = nums.length;
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            if (nums[i] > nums[(i + 1) % n]) {
+                ++cnt;
+            }
+        }
+        return cnt <= 1;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool check(vector<int>& nums) {
+        int n = nums.size();
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            cnt += nums[i] > (nums[(i + 1) % n]);
+        }
+        return cnt <= 1;
+    }
+};
+```
 
+### **Go**
+
+```go
+func check(nums []int) bool {
+	n := len(nums)
+	cnt := 0
+	for i, v := range nums {
+		if v > nums[(i+1)%n] {
+			cnt++
+		}
+	}
+	return cnt <= 1
+}
 ```
 
 ### **...**

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/Solution.cpp

@@ -0,0 +1,11 @@
+class Solution {
+public:
+    bool check(vector<int>& nums) {
+        int n = nums.size();
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            cnt += nums[i] > (nums[(i + 1) % n]);
+        }
+        return cnt <= 1;
+    }
+};

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/Solution.go

@@ -0,0 +1,10 @@
+func check(nums []int) bool {
+	n := len(nums)
+	cnt := 0
+	for i, v := range nums {
+		if v > nums[(i+1)%n] {
+			cnt++
+		}
+	}
+	return cnt <= 1
+}

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/Solution.java

@@ -0,0 +1,12 @@
+class Solution {
+    public boolean check(int[] nums) {
+        int n = nums.length;
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            if (nums[i] > nums[(i + 1) % n]) {
+                ++cnt;
+            }
+        }
+        return cnt <= 1;
+    }
+}

solution/1700-1799/1752.Check if Array Is Sorted and Rotated/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def check(self, nums: List[int]) -> bool:
+        n = len(nums)
+        return sum(v > nums[(i + 1) % n] for i, v in enumerate(nums)) <= 1

solution/2400-2499/2425.Bitwise XOR of All Pairings/Solution.ts

@@ -7,4 +7,4 @@ function xorAllNums(nums1: number[], nums2: number[]): number {
         ans ^= nums2.reduce((a, c) => a ^ c, 0);
     }
     return ans;
-};
+}

solution/2400-2499/2428.Maximum Sum of an Hourglass/Solution.ts

@@ -1,5 +1,6 @@
 function maxSum(grid: number[][]): number {
-    const m = grid.length, n = grid[0].length;
+    const m = grid.length,
+        n = grid[0].length;
     let threeSum = Array.from({ length: m }, () => new Array(n - 2).fill(0));
     for (let i = 0; i < m; i++) {
         for (let j = 1; j < n - 1; j++) {
@@ -9,8 +10,11 @@ function maxSum(grid: number[][]): number {
     let ans = 0;
     for (let i = 1; i < m - 1; i++) {
         for (let j = 1; j < n - 1; j++) {
-            ans = Math.max(ans, threeSum[i - 1][j - 1] + grid[i][j] + threeSum[i + 1][j - 1]);
+            ans = Math.max(
+                ans,
+                threeSum[i - 1][j - 1] + grid[i][j] + threeSum[i + 1][j - 1],
+            );
         }
     }
     return ans;
-};
+}

solution/2400-2499/2429.Minimize XOR/Solution.ts

@@ -1,7 +1,13 @@
 function minimizeXor(num1: number, num2: number): number {
     let ans = num1;
-    let target = num1.toString(2).split('').reduce((a, c) => a + Number(c), 0);
-    let count = num2.toString(2).split('').reduce((a, c) => a + Number(c), 0);
+    let target = num1
+        .toString(2)
+        .split('')
+        .reduce((a, c) => a + Number(c), 0);
+    let count = num2
+        .toString(2)
+        .split('')
+        .reduce((a, c) => a + Number(c), 0);
     while (count > target) {
         ans |= ans + 1;
         count -= 1;
@@ -11,4 +17,4 @@ function minimizeXor(num1: number, num2: number): number {
         count += 1;
     }
     return ans;
-};
+}

solution/2400-2499/2437.Number of Valid Clock Times/Solution.ts

@@ -1,7 +1,7 @@
 function countTime(time: string): number {
     let [hh, mm] = time.split(':');
     return count(hh, 24) * count(mm, 60);
-};
+}
 
 function count(str: string, limit: number): number {
     let [a, b] = str.split('').map(d => Number(d));
@@ -20,4 +20,4 @@ function count(str: string, limit: number): number {
         return ans;
     }
     return 1;
-}
+}