feat: add solutions to lc problems: No.2855~2858

* No.2855.Minimum Right Shifts to Sort the Array
* No.2856.Minimum Array Length After Pair Removals
* No.2857.Count Pairs of Points With Distance k

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/README.md

@@ -52,34 +52,107 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：直接遍历**
+
+我们先用一个指针 $i$ 从左到右遍历数组 $nums$，找出一段连续的递增序列，直到 $i$ 到达数组末尾或者 $nums[i - 1] \gt nums[i]$。接下来我们用另一个指针 $k$ 从 $i + 1$ 开始遍历数组 $nums$，找出一段连续的递增序列，直到 $k$ 到达数组末尾或者 $nums[k - 1] \gt nums[k]$ 且 $nums[k] \gt nums[0]$。如果 $k$ 到达数组末尾，说明数组已经是递增的，返回 $n - i$；否则返回 $-1$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是数组 $nums$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minimumRightShifts(self, nums: List[int]) -> int:
+        n = len(nums)
+        i = 1
+        while i < n and nums[i - 1] < nums[i]:
+            i += 1
+        k = i + 1
+        while k < n and nums[k - 1] < nums[k] < nums[0]:
+            k += 1
+        return -1 if k < n else n - i
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int minimumRightShifts(List<Integer> nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums.get(i - 1) < nums.get(i)) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int minimumRightShifts(vector<int>& nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums[i - 1] < nums[i]) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func minimumRightShifts(nums []int) int {
+	n := len(nums)
+	i := 1
+	for i < n && nums[i-1] < nums[i] {
+		i++
+	}
+	k := i + 1
+	for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
+		k++
+	}
+	if k < n {
+		return -1
+	}
+	return n - i
+}
+```
 
+### **TypeScript**
+
+```ts
+function minimumRightShifts(nums: number[]): number {
+    const n = nums.length;
+    let i = 1;
+    while (i < n && nums[i - 1] < nums[i]) {
+        ++i;
+    }
+    let k = i + 1;
+    while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+        ++k;
+    }
+    return k < n ? -1 : n - i;
+}
 ```
 
 ### **...**

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/README_EN.md

@@ -51,25 +51,92 @@ Now nums is sorted; therefore the answer is 2.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def minimumRightShifts(self, nums: List[int]) -> int:
+        n = len(nums)
+        i = 1
+        while i < n and nums[i - 1] < nums[i]:
+            i += 1
+        k = i + 1
+        while k < n and nums[k - 1] < nums[k] < nums[0]:
+            k += 1
+        return -1 if k < n else n - i
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int minimumRightShifts(List<Integer> nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums.get(i - 1) < nums.get(i)) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int minimumRightShifts(vector<int>& nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums[i - 1] < nums[i]) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func minimumRightShifts(nums []int) int {
+	n := len(nums)
+	i := 1
+	for i < n && nums[i-1] < nums[i] {
+		i++
+	}
+	k := i + 1
+	for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
+		k++
+	}
+	if k < n {
+		return -1
+	}
+	return n - i
+}
+```
 
+### **TypeScript**
+
+```ts
+function minimumRightShifts(nums: number[]): number {
+    const n = nums.length;
+    let i = 1;
+    while (i < n && nums[i - 1] < nums[i]) {
+        ++i;
+    }
+    let k = i + 1;
+    while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+        ++k;
+    }
+    return k < n ? -1 : n - i;
+}
 ```
 
 ### **...**

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/Solution.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int minimumRightShifts(vector<int>& nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums[i - 1] < nums[i]) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+};

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/Solution.go

@@ -0,0 +1,15 @@
+func minimumRightShifts(nums []int) int {
+	n := len(nums)
+	i := 1
+	for i < n && nums[i-1] < nums[i] {
+		i++
+	}
+	k := i + 1
+	for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
+		k++
+	}
+	if k < n {
+		return -1
+	}
+	return n - i
+}

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/Solution.java

@@ -0,0 +1,14 @@
+class Solution {
+    public int minimumRightShifts(List<Integer> nums) {
+        int n = nums.size();
+        int i = 1;
+        while (i < n && nums.get(i - 1) < nums.get(i)) {
+            ++i;
+        }
+        int k = i + 1;
+        while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
+            ++k;
+        }
+        return k < n ? -1 : n - i;
+    }
+}

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def minimumRightShifts(self, nums: List[int]) -> int:
+        n = len(nums)
+        i = 1
+        while i < n and nums[i - 1] < nums[i]:
+            i += 1
+        k = i + 1
+        while k < n and nums[k - 1] < nums[k] < nums[0]:
+            k += 1
+        return -1 if k < n else n - i

solution/2800-2899/2855.Minimum Right Shifts to Sort the Array/Solution.ts

@@ -0,0 +1,12 @@
+function minimumRightShifts(nums: number[]): number {
+    const n = nums.length;
+    let i = 1;
+    while (i < n && nums[i - 1] < nums[i]) {
+        ++i;
+    }
+    let k = i + 1;
+    while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
+        ++k;
+    }
+    return k < n ? -1 : n - i;
+}