Skip to content

Commit 907340b

Browse files
yanglbmeyanglbme
committed
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
1 parent f284d91 commit 907340b

File tree

21 files changed

+895
-16
lines changed

21 files changed

+895
-16
lines changed

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

Lines changed: 76 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -52,34 +52,107 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：直接遍历**
56+
57+
我们先用一个指针 $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$。
58+
59+
时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是数组 $nums$ 的长度。
60+
5561
<!-- tabs:start -->
5662

5763
### **Python3**
5864

5965
<!-- 这里可写当前语言的特殊实现逻辑 -->
6066

6167
```python
62-
68+
class Solution:
69+
def minimumRightShifts(self, nums: List[int]) -> int:
70+
n = len(nums)
71+
i = 1
72+
while i < n and nums[i - 1] < nums[i]:
73+
i += 1
74+
k = i + 1
75+
while k < n and nums[k - 1] < nums[k] < nums[0]:
76+
k += 1
77+
return -1 if k < n else n - i
6378
```
6479

6580
### **Java**
6681

6782
<!-- 这里可写当前语言的特殊实现逻辑 -->
6883

6984
```java
70-
85+
class Solution {
86+
public int minimumRightShifts(List<Integer> nums) {
87+
int n = nums.size();
88+
int i = 1;
89+
while (i < n && nums.get(i - 1) < nums.get(i)) {
90+
++i;
91+
}
92+
int k = i + 1;
93+
while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
94+
++k;
95+
}
96+
return k < n ? -1 : n - i;
97+
}
98+
}
7199
```
72100

73101
### **C++**
74102

75103
```cpp
76-
104+
class Solution {
105+
public:
106+
int minimumRightShifts(vector<int>& nums) {
107+
int n = nums.size();
108+
int i = 1;
109+
while (i < n && nums[i - 1] < nums[i]) {
110+
++i;
111+
}
112+
int k = i + 1;
113+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
114+
++k;
115+
}
116+
return k < n ? -1 : n - i;
117+
}
118+
};
77119
```
78120
79121
### **Go**
80122
81123
```go
124+
func minimumRightShifts(nums []int) int {
125+
n := len(nums)
126+
i := 1
127+
for i < n && nums[i-1] < nums[i] {
128+
i++
129+
}
130+
k := i + 1
131+
for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
132+
k++
133+
}
134+
if k < n {
135+
return -1
136+
}
137+
return n - i
138+
}
139+
```
82140

141+
### **TypeScript**
142+
143+
```ts
144+
function minimumRightShifts(nums: number[]): number {
145+
const n = nums.length;
146+
let i = 1;
147+
while (i < n && nums[i - 1] < nums[i]) {
148+
++i;
149+
}
150+
let k = i + 1;
151+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
152+
++k;
153+
}
154+
return k < n ? -1 : n - i;
155+
}
83156
```
84157

85158
### **...**

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

Lines changed: 70 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -51,25 +51,92 @@ Now nums is sorted; therefore the answer is 2.
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def minimumRightShifts(self, nums: List[int]) -> int:
56+
n = len(nums)
57+
i = 1
58+
while i < n and nums[i - 1] < nums[i]:
59+
i += 1
60+
k = i + 1
61+
while k < n and nums[k - 1] < nums[k] < nums[0]:
62+
k += 1
63+
return -1 if k < n else n - i
5564
```
5665

5766
### **Java**
5867

5968
```java
60-
69+
class Solution {
70+
public int minimumRightShifts(List<Integer> nums) {
71+
int n = nums.size();
72+
int i = 1;
73+
while (i < n && nums.get(i - 1) < nums.get(i)) {
74+
++i;
75+
}
76+
int k = i + 1;
77+
while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
78+
++k;
79+
}
80+
return k < n ? -1 : n - i;
81+
}
82+
}
6183
```
6284

6385
### **C++**
6486

6587
```cpp
66-
88+
class Solution {
89+
public:
90+
int minimumRightShifts(vector<int>& nums) {
91+
int n = nums.size();
92+
int i = 1;
93+
while (i < n && nums[i - 1] < nums[i]) {
94+
++i;
95+
}
96+
int k = i + 1;
97+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
98+
++k;
99+
}
100+
return k < n ? -1 : n - i;
101+
}
102+
};
67103
```
68104
69105
### **Go**
70106
71107
```go
108+
func minimumRightShifts(nums []int) int {
109+
n := len(nums)
110+
i := 1
111+
for i < n && nums[i-1] < nums[i] {
112+
i++
113+
}
114+
k := i + 1
115+
for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
116+
k++
117+
}
118+
if k < n {
119+
return -1
120+
}
121+
return n - i
122+
}
123+
```
72124

125+
### **TypeScript**
126+
127+
```ts
128+
function minimumRightShifts(nums: number[]): number {
129+
const n = nums.length;
130+
let i = 1;
131+
while (i < n && nums[i - 1] < nums[i]) {
132+
++i;
133+
}
134+
let k = i + 1;
135+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
136+
++k;
137+
}
138+
return k < n ? -1 : n - i;
139+
}
73140
```
74141

75142
### **...**

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public:
3+
int minimumRightShifts(vector<int>& nums) {
4+
int n = nums.size();
5+
int i = 1;
6+
while (i < n && nums[i - 1] < nums[i]) {
7+
++i;
8+
}
9+
int k = i + 1;
10+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
11+
++k;
12+
}
13+
return k < n ? -1 : n - i;
14+
}
15+
};

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
func minimumRightShifts(nums []int) int {
2+
n := len(nums)
3+
i := 1
4+
for i < n && nums[i-1] < nums[i] {
5+
i++
6+
}
7+
k := i + 1
8+
for k < n && nums[k-1] < nums[k] && nums[k] < nums[0] {
9+
k++
10+
}
11+
if k < n {
12+
return -1
13+
}
14+
return n - i
15+
}

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

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public int minimumRightShifts(List<Integer> nums) {
3+
int n = nums.size();
4+
int i = 1;
5+
while (i < n && nums.get(i - 1) < nums.get(i)) {
6+
++i;
7+
}
8+
int k = i + 1;
9+
while (k < n && nums.get(k - 1) < nums.get(k) && nums.get(k) < nums.get(0)) {
10+
++k;
11+
}
12+
return k < n ? -1 : n - i;
13+
}
14+
}

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

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def minimumRightShifts(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
i = 1
5+
while i < n and nums[i - 1] < nums[i]:
6+
i += 1
7+
k = i + 1
8+
while k < n and nums[k - 1] < nums[k] < nums[0]:
9+
k += 1
10+
return -1 if k < n else n - i

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

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
function minimumRightShifts(nums: number[]): number {
2+
const n = nums.length;
3+
let i = 1;
4+
while (i < n && nums[i - 1] < nums[i]) {
5+
++i;
6+
}
7+
let k = i + 1;
8+
while (k < n && nums[k - 1] < nums[k] && nums[k] < nums[0]) {
9+
++k;
10+
}
11+
return k < n ? -1 : n - i;
12+
}

0 commit comments

Comments
 (0)