feat: update solutions to lc problem: No.0436

* No.0436.Find Right Interval

Author: yanglbme

solution/0400-0499/0436.Find Right Interval/README.md

@@ -55,7 +55,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二分查找。
+**方法一：二分查找**
 
 <!-- tabs:start -->
 
@@ -66,20 +66,16 @@
 ```python
 class Solution:
     def findRightInterval(self, intervals: List[List[int]]) -> List[int]:
+        for i, v in enumerate(intervals):
+            v.append(i)
+        intervals.sort()
         n = len(intervals)
-        starts = [(intervals[i][0], i) for i in range(n)]
-        starts.sort(key=lambda x : x[0])
-        res = []
-        for _, end in intervals:
-            left, right = 0, n - 1
-            while left < right:
-                mid = (left + right) >> 1
-                if starts[mid][0] >= end:
-                    right = mid
-                else:
-                    left = mid + 1
-            res.append(-1 if starts[left][0] < end else starts[left][1])
-        return res
+        ans = [-1] * n
+        for _, e, i in intervals:
+            j = bisect_left(intervals, [e])
+            if j < n:
+                ans[i] = intervals[j][2]
+        return ans
 ```
 
 ### **Java**

solution/0400-0499/0436.Find Right Interval/README_EN.md

@@ -59,20 +59,16 @@ Binary search.
 ```python
 class Solution:
     def findRightInterval(self, intervals: List[List[int]]) -> List[int]:
+        for i, v in enumerate(intervals):
+            v.append(i)
+        intervals.sort()
         n = len(intervals)
-        starts = [(intervals[i][0], i) for i in range(n)]
-        starts.sort(key=lambda x : x[0])
-        res = []
-        for _, end in intervals:
-            left, right = 0, n - 1
-            while left < right:
-                mid = (left + right) >> 1
-                if starts[mid][0] >= end:
-                    right = mid
-                else:
-                    left = mid + 1
-            res.append(-1 if starts[left][0] < end else starts[left][1])
-        return res
+        ans = [-1] * n
+        for _, e, i in intervals:
+            j = bisect_left(intervals, [e])
+            if j < n:
+                ans[i] = intervals[j][2]
+        return ans
 ```
 
 ### **Java**

solution/0400-0499/0436.Find Right Interval/Solution.py

@@ -1,16 +1,12 @@
 class Solution:
     def findRightInterval(self, intervals: List[List[int]]) -> List[int]:
+        for i, v in enumerate(intervals):
+            v.append(i)
+        intervals.sort()
         n = len(intervals)
-        starts = [(intervals[i][0], i) for i in range(n)]
-        starts.sort(key=lambda x: x[0])
-        res = []
-        for _, end in intervals:
-            left, right = 0, n - 1
-            while left < right:
-                mid = (left + right) >> 1
-                if starts[mid][0] >= end:
-                    right = mid
-                else:
-                    left = mid + 1
-            res.append(-1 if starts[left][0] < end else starts[left][1])
-        return res
+        ans = [-1] * n
+        for _, e, i in intervals:
+            j = bisect_left(intervals, [e])
+            if j < n:
+                ans[i] = intervals[j][2]
+        return ans

solution/1500-1599/1534.Count Good Triplets/Solution.py

@@ -5,6 +5,10 @@ def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
         for i in range(n):
             for j in range(i + 1, n):
                 for k in range(j + 1, n):
-                    if abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:
+                    if (
+                        abs(arr[i] - arr[j]) <= a
+                        and abs(arr[j] - arr[k]) <= b
+                        and abs(arr[i] - arr[k]) <= c
+                    ):
                         ans += 1
         return ans

solution/2200-2299/2259.Remove Digit From Number to Maximize Result/Solution.ts

@@ -5,8 +5,8 @@ function removeDigit(number: string, digit: string): string {
     for (let i = 0; i < n; i++) {
         if (nums[i] != digit) continue;
         ans = i;
-        if ((i + 1 < n) && (nums[i + 1] > nums[i])) break;
+        if (i + 1 < n && nums[i + 1] > nums[i]) break;
     }
     nums.splice(ans, 1);
     return nums.join('');
-};
+}

solution/2200-2299/2260.Minimum Consecutive Cards to Pick Up/Solution.ts

@@ -11,4 +11,4 @@ function minimumCardPickup(cards: number[]): number {
         hashMap.set(num, i);
     }
     return ans == max ? -1 : ans;
-};
+}

solution/2200-2299/2261.K Divisible Elements Subarrays/Solution.ts

@@ -19,4 +19,4 @@ function countDistinct(nums: number[], k: number, p: number): number {
         }
     }
     return ans.size;
-};
+}

solution/2200-2299/2262.Total Appeal of A String/Solution.ts

@@ -8,4 +8,4 @@ function appealSum(s: string): number {
         hashMap.set(c, i + 1);
     }
     return dp.reduce((a, c) => a + c, 0);
-};
+}

solution/2200-2299/2264.Largest 3-Same-Digit Number in String/Solution.ts

@@ -4,4 +4,4 @@ function largestGoodInteger(num: string): string {
         if (num.includes(c)) return c;
     }
     return '';
-};
+}

solution/2200-2299/2273.Find Resultant Array After Removing Anagrams/Solution.ts

@@ -11,12 +11,12 @@ function removeAnagrams(words: string[]): string[] {
         }
     }
     return ans;
-};
+}
 
-function countWord (word: string): number[] {
+function countWord(word: string): number[] {
     let count = new Array(128).fill(0);
     for (let i = 0; i < word.length; i++) {
         count[word.charCodeAt(i)]++;
     }
     return count;
-}
+}