feat: solve No.1266,2264

BaffinLee · BaffinLee · commit 8b40a17fb31a · 2023-12-04T05:17:30.000Z
diff --git a/1201-1300/1266. Minimum Time Visiting All Points.md b/1201-1300/1266. Minimum Time Visiting All Points.md
@@ -0,0 +1,92 @@
+# 1266. Minimum Time Visiting All Points
+
+- Difficulty: Easy.
+- Related Topics: Array, Math, Geometry.
+- Similar Questions: .
+
+## Problem
+
+On a 2D plane, there are `n` points with integer coordinates `points[i] = [xi, yi]`. Return **the **minimum time** in seconds to visit all the points in the order given by **`points`.
+
+You can move according to these rules:
+
+
+	In `1` second, you can either:
+
+	
+		
+- move vertically by one unit,
+		
+- move horizontally by one unit, or
+		
+- move diagonally `sqrt(2)` units (in other words, move one unit vertically then one unit horizontally in `1` second).
+	
+	
+	
+- You have to visit the points in the same order as they appear in the array.
+	
+- You are allowed to pass through points that appear later in the order, but these do not count as visits.
+
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2019/11/14/1626_example_1.PNG)
+
+```
+Input: points = [[1,1],[3,4],[-1,0]]
+Output: 7
+Explanation: One optimal path is [1,1] -> [2,2] -> [3,3] -> [3,4] -> [2,3] -> [1,2] -> [0,1] -> [-1,0]   
+Time from [1,1] to [3,4] = 3 seconds 
+Time from [3,4] to [-1,0] = 4 seconds
+Total time = 7 seconds
+```
+
+Example 2:
+
+```
+Input: points = [[3,2],[-2,2]]
+Output: 5
+```
+
+ 
+**Constraints:**
+
+
+	
+- `points.length == n`
+	
+- `1 <= n <= 100`
+	
+- `points[i].length == 2`
+	
+- `-1000 <= points[i][0], points[i][1] <= 1000`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var minTimeToVisitAllPoints = function(points) {
+    return points.reduce((sum, point, index) => {
+        if (index === 0) return 0;
+        var diffX = Math.abs(point[0] - points[index - 1][0]);
+        var diffY = Math.abs(point[1] - points[index - 1][1]);
+        var second = Math.max(diffX, diffY);
+        return sum + second;
+    }, 0);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).
diff --git a/2201-2300/2264. Largest 3-Same-Digit Number in String.md b/2201-2300/2264. Largest 3-Same-Digit Number in String.md
@@ -0,0 +1,97 @@
+# 2264. Largest 3-Same-Digit Number in String
+
+- Difficulty: Easy.
+- Related Topics: String.
+- Similar Questions: Largest Odd Number in String.
+
+## Problem
+
+You are given a string `num` representing a large integer. An integer is **good** if it meets the following conditions:
+
+
+	
+- It is a **substring** of `num` with length `3`.
+	
+- It consists of only one unique digit.
+
+
+Return **the **maximum good **integer as a **string** or an empty string **`""`** if no such integer exists**.
+
+Note:
+
+
+	
+- A **substring** is a contiguous sequence of characters within a string.
+	
+- There may be **leading zeroes** in `num` or a good integer.
+
+
+ 
+Example 1:
+
+```
+Input: num = "6777133339"
+Output: "777"
+Explanation: There are two distinct good integers: "777" and "333".
+"777" is the largest, so we return "777".
+```
+
+Example 2:
+
+```
+Input: num = "2300019"
+Output: "000"
+Explanation: "000" is the only good integer.
+```
+
+Example 3:
+
+```
+Input: num = "42352338"
+Output: ""
+Explanation: No substring of length 3 consists of only one unique digit. Therefore, there are no good integers.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `3 <= num.length <= 1000`
+	
+- `num` only consists of digits.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {string} num
+ * @return {string}
+ */
+var largestGoodInteger = function(num) {
+    var maxDigit = '';
+    var digitLength = 0;
+    for (var i = 0; i < num.length; i++) {
+        if (num[i] === num[i - 1]) {
+            digitLength += 1;
+            if (digitLength >= 3 && num[i] > maxDigit) {
+                maxDigit = num[i];
+            }
+        } else {
+            digitLength = 1;
+        }
+    }
+    return maxDigit.repeat(3);
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).
