[pull] main from doocs:main

solution/1000-1099/1060.Missing Element in Sorted Array/README.md

@@ -55,22 +55,115 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：二分查找**
+
+我们设计一个函数 $missing(i)$，表示 $nums[i]$ 与 $nums[0]$ 之间缺失的元素个数。那么 $missing(i)$ 就等于 $nums[i] - nums[0] - i$。我们可以通过二分查找找到最小的 $i$，使得 $missing(i) \geq k$，那么 $nums[i - 1] + k - missing(i - 1)$ 就是第 $k$ 个缺失的元素。
+
+时间复杂度 $O(\log n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 $nums$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def missingElement(self, nums: List[int], k: int) -> int:
+        def missing(i: int) -> int:
+            return nums[i] - nums[0] - i
+
+        n = len(nums)
+        if k > missing(n - 1):
+            return nums[n - 1] + k - missing(n - 1)
+        l, r = 0, n - 1
+        while l < r:
+            mid = (l + r) >> 1
+            if missing(mid) >= k:
+                r = mid
+            else:
+                l = mid + 1
+        return nums[l - 1] + k - missing(l - 1)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int missingElement(int[] nums, int k) {
+        int n = nums.length;
+        if (k > missing(nums, n - 1)) {
+            return nums[n - 1] + k - missing(nums, n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(nums, mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(nums, l - 1);
+    }
+
+    private int missing(int[] nums, int i) {
+        return nums[i] - nums[0] - i;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int missingElement(vector<int>& nums, int k) {
+        auto missing = [&](int i) {
+            return nums[i] - nums[0] - i;
+        };
+        int n = nums.size();
+        if (k > missing(n - 1)) {
+            return nums[n - 1] + k - missing(n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(l - 1);
+    }
+};
+```
 
+### **Go**
+
+```go
+func missingElement(nums []int, k int) int {
+	missing := func(i int) int {
+		return nums[i] - nums[0] - i
+	}
+	n := len(nums)
+	if k > missing(n-1) {
+		return nums[n-1] + k - missing(n-1)
+	}
+	l, r := 0, n-1
+	for l < r {
+		mid := (l + r) >> 1
+		if missing(mid) >= k {
+			r = mid
+		} else {
+			l = mid + 1
+		}
+	}
+	return nums[l-1] + k - missing(l-1)
+}
 ```
 
 ### **...**

solution/1000-1099/1060.Missing Element in Sorted Array/README_EN.md

@@ -51,13 +51,100 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def missingElement(self, nums: List[int], k: int) -> int:
+        def missing(i: int) -> int:
+            return nums[i] - nums[0] - i
+
+        n = len(nums)
+        if k > missing(n - 1):
+            return nums[n - 1] + k - missing(n - 1)
+        l, r = 0, n - 1
+        while l < r:
+            mid = (l + r) >> 1
+            if missing(mid) >= k:
+                r = mid
+            else:
+                l = mid + 1
+        return nums[l - 1] + k - missing(l - 1)
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int missingElement(int[] nums, int k) {
+        int n = nums.length;
+        if (k > missing(nums, n - 1)) {
+            return nums[n - 1] + k - missing(nums, n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(nums, mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(nums, l - 1);
+    }
+
+    private int missing(int[] nums, int i) {
+        return nums[i] - nums[0] - i;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int missingElement(vector<int>& nums, int k) {
+        auto missing = [&](int i) {
+            return nums[i] - nums[0] - i;
+        };
+        int n = nums.size();
+        if (k > missing(n - 1)) {
+            return nums[n - 1] + k - missing(n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(l - 1);
+    }
+};
+```
 
+### **Go**
+
+```go
+func missingElement(nums []int, k int) int {
+	missing := func(i int) int {
+		return nums[i] - nums[0] - i
+	}
+	n := len(nums)
+	if k > missing(n-1) {
+		return nums[n-1] + k - missing(n-1)
+	}
+	l, r := 0, n-1
+	for l < r {
+		mid := (l + r) >> 1
+		if missing(mid) >= k {
+			r = mid
+		} else {
+			l = mid + 1
+		}
+	}
+	return nums[l-1] + k - missing(l-1)
+}
 ```
 
 ### **...**

solution/1000-1099/1060.Missing Element in Sorted Array/Solution.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int missingElement(vector<int>& nums, int k) {
+        auto missing = [&](int i) {
+            return nums[i] - nums[0] - i;
+        };
+        int n = nums.size();
+        if (k > missing(n - 1)) {
+            return nums[n - 1] + k - missing(n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(l - 1);
+    }
+};

solution/1000-1099/1060.Missing Element in Sorted Array/Solution.go

@@ -0,0 +1,19 @@
+func missingElement(nums []int, k int) int {
+	missing := func(i int) int {
+		return nums[i] - nums[0] - i
+	}
+	n := len(nums)
+	if k > missing(n-1) {
+		return nums[n-1] + k - missing(n-1)
+	}
+	l, r := 0, n-1
+	for l < r {
+		mid := (l + r) >> 1
+		if missing(mid) >= k {
+			r = mid
+		} else {
+			l = mid + 1
+		}
+	}
+	return nums[l-1] + k - missing(l-1)
+}

solution/1000-1099/1060.Missing Element in Sorted Array/Solution.java

@@ -0,0 +1,22 @@
+class Solution {
+    public int missingElement(int[] nums, int k) {
+        int n = nums.length;
+        if (k > missing(nums, n - 1)) {
+            return nums[n - 1] + k - missing(nums, n - 1);
+        }
+        int l = 0, r = n - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (missing(nums, mid) >= k) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return nums[l - 1] + k - missing(nums, l - 1);
+    }
+
+    private int missing(int[] nums, int i) {
+        return nums[i] - nums[0] - i;
+    }
+}

solution/1000-1099/1060.Missing Element in Sorted Array/Solution.py

@@ -0,0 +1,16 @@
+class Solution:
+    def missingElement(self, nums: List[int], k: int) -> int:
+        def missing(i: int) -> int:
+            return nums[i] - nums[0] - i
+
+        n = len(nums)
+        if k > missing(n - 1):
+            return nums[n - 1] + k - missing(n - 1)
+        l, r = 0, n - 1
+        while l < r:
+            mid = (l + r) >> 1
+            if missing(mid) >= k:
+                r = mid
+            else:
+                l = mid + 1
+        return nums[l - 1] + k - missing(l - 1)

solution/1200-1299/1287.Element Appearing More Than 25% In Sorted Array/README.md

@@ -112,6 +112,24 @@ var findSpecialInteger = function (arr) {
 };
 ```
 
+### **PHP**
+
+```php 
+class Solution {
+    /**
+     * @param Integer[] $arr
+     * @return Integer
+     */
+    function findSpecialInteger($arr) {
+        $len = count($arr);
+        for ($i = 0; $i < $len; $i++) {
+            if ($arr[$i] == $arr[$i + ($len >> 2)]) return $arr[$i];
+        }
+        return -1;
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1200-1299/1287.Element Appearing More Than 25% In Sorted Array/README_EN.md

@@ -107,6 +107,24 @@ var findSpecialInteger = function (arr) {
 };
 ```
 
+### **PHP**
+
+```php
+class Solution {
+    /**
+     * @param Integer[] $arr
+     * @return Integer
+     */
+    function findSpecialInteger($arr) {
+        $len = count($arr);
+        for ($i = 0; $i < $len; $i++) {
+            if ($arr[$i] == $arr[$i + ($len >> 2)]) return $arr[$i];
+        }
+        return -1;
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1200-1299/1287.Element Appearing More Than 25% In Sorted Array/Solution.php

@@ -0,0 +1,13 @@
+class Solution {
+    /**
+     * @param Integer[] $arr
+     * @return Integer
+     */
+    function findSpecialInteger($arr) {
+        $len = count($arr);
+        for ($i = 0; $i < $len; $i++) {
+            if ($arr[$i] == $arr[$i + ($len >> 2)]) return $arr[$i];
+        }
+        return -1;
+    }
+}