Skip to content

Commit 0ada84f

Browse files
yanglbmethinkasany
yanglbme
authored and
thinkasany
committed
feat: add solutions to lc problem: No.1040
No.1040.Moving Stones Until Consecutive II
1 parent adcc0af commit 0ada84f

File tree

6 files changed

+277
-2
lines changed

6 files changed

+277
-2
lines changed

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/README.md

+98-1
Original file line numberDiff line numberDiff line change
@@ -61,22 +61,119 @@
6161

6262
<!-- 这里可写通用的实现逻辑 -->
6363

64+
**方法一：排序 + 分类讨论 + 双指针**
65+
66+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `stones` 的长度。
67+
6468
<!-- tabs:start -->
6569

6670
### **Python3**
6771

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

7074
```python
71-
75+
class Solution:
76+
def numMovesStonesII(self, stones: List[int]) -> List[int]:
77+
stones.sort()
78+
mi = n = len(stones)
79+
mx = max(stones[-1] - stones[1] + 1, stones[-2] - stones[0] + 1) - (n - 1)
80+
i = 0
81+
for j, x in enumerate(stones):
82+
while x - stones[i] + 1 > n:
83+
i += 1
84+
if j - i + 1 == n - 1 and x - stones[i] == n - 2:
85+
mi = min(mi, 2)
86+
else:
87+
mi = min(mi, n - (j - i + 1))
88+
return [mi, mx]
7289
```
7390

7491
### **Java**
7592

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

7895
```java
96+
class Solution {
97+
public int[] numMovesStonesII(int[] stones) {
98+
Arrays.sort(stones);
99+
int n = stones.length;
100+
int mi = n;
101+
int mx = Math.max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
102+
for (int i = 0, j = 0; j < n; ++j) {
103+
while (stones[j] - stones[i] + 1 > n) {
104+
++i;
105+
}
106+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
107+
mi = Math.min(mi, 2);
108+
} else {
109+
mi = Math.min(mi, n - (j - i + 1));
110+
}
111+
}
112+
return new int[] {mi, mx};
113+
}
114+
}
115+
```
116+
117+
### **C++**
118+
119+
```cpp
120+
class Solution {
121+
public:
122+
vector<int> numMovesStonesII(vector<int>& stones) {
123+
sort(stones.begin(), stones.end());
124+
int n = stones.size();
125+
int mi = n;
126+
int mx = max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
127+
for (int i = 0, j = 0; j < n; ++j) {
128+
while (stones[j] - stones[i] + 1 > n) {
129+
++i;
130+
}
131+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
132+
mi = min(mi, 2);
133+
} else {
134+
mi = min(mi, n - (j - i + 1));
135+
}
136+
}
137+
return {mi, mx};
138+
}
139+
};
140+
```
79141
142+
### **Go**
143+
144+
```go
145+
func numMovesStonesII(stones []int) []int {
146+
sort.Ints(stones)
147+
n := len(stones)
148+
mi := n
149+
mx := max(stones[n-1]-stones[1]+1, stones[n-2]-stones[0]+1) - (n - 1)
150+
i := 0
151+
for j, x := range stones {
152+
for x-stones[i]+1 > n {
153+
i++
154+
}
155+
if j-i+1 == n-1 && stones[j]-stones[i] == n-2 {
156+
mi = min(mi, 2)
157+
} else {
158+
mi = min(mi, n-(j-i+1))
159+
}
160+
}
161+
return []int{mi, mx}
162+
}
163+
164+
func max(a, b int) int {
165+
if a > b {
166+
return a
167+
}
168+
return b
169+
}
170+
171+
func min(a, b int) int {
172+
if a < b {
173+
return a
174+
}
175+
return b
176+
}
80177
```
81178

82179
### **...**

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/README_EN.md

+94-1
Original file line numberDiff line numberDiff line change
@@ -57,13 +57,106 @@ Notice we cannot move 10 -&gt; 2 to finish the game, because that would be an il
5757
### **Python3**
5858

5959
```python
60-
60+
class Solution:
61+
def numMovesStonesII(self, stones: List[int]) -> List[int]:
62+
stones.sort()
63+
mi = n = len(stones)
64+
mx = max(stones[-1] - stones[1] + 1, stones[-2] - stones[0] + 1) - (n - 1)
65+
i = 0
66+
for j, x in enumerate(stones):
67+
while x - stones[i] + 1 > n:
68+
i += 1
69+
if j - i + 1 == n - 1 and x - stones[i] == n - 2:
70+
mi = min(mi, 2)
71+
else:
72+
mi = min(mi, n - (j - i + 1))
73+
return [mi, mx]
6174
```
6275

6376
### **Java**
6477

6578
```java
79+
class Solution {
80+
public int[] numMovesStonesII(int[] stones) {
81+
Arrays.sort(stones);
82+
int n = stones.length;
83+
int mi = n;
84+
int mx = Math.max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
85+
for (int i = 0, j = 0; j < n; ++j) {
86+
while (stones[j] - stones[i] + 1 > n) {
87+
++i;
88+
}
89+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
90+
mi = Math.min(mi, 2);
91+
} else {
92+
mi = Math.min(mi, n - (j - i + 1));
93+
}
94+
}
95+
return new int[] {mi, mx};
96+
}
97+
}
98+
```
99+
100+
### **C++**
101+
102+
```cpp
103+
class Solution {
104+
public:
105+
vector<int> numMovesStonesII(vector<int>& stones) {
106+
sort(stones.begin(), stones.end());
107+
int n = stones.size();
108+
int mi = n;
109+
int mx = max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
110+
for (int i = 0, j = 0; j < n; ++j) {
111+
while (stones[j] - stones[i] + 1 > n) {
112+
++i;
113+
}
114+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
115+
mi = min(mi, 2);
116+
} else {
117+
mi = min(mi, n - (j - i + 1));
118+
}
119+
}
120+
return {mi, mx};
121+
}
122+
};
123+
```
66124
125+
### **Go**
126+
127+
```go
128+
func numMovesStonesII(stones []int) []int {
129+
sort.Ints(stones)
130+
n := len(stones)
131+
mi := n
132+
mx := max(stones[n-1]-stones[1]+1, stones[n-2]-stones[0]+1) - (n - 1)
133+
i := 0
134+
for j, x := range stones {
135+
for x-stones[i]+1 > n {
136+
i++
137+
}
138+
if j-i+1 == n-1 && stones[j]-stones[i] == n-2 {
139+
mi = min(mi, 2)
140+
} else {
141+
mi = min(mi, n-(j-i+1))
142+
}
143+
}
144+
return []int{mi, mx}
145+
}
146+
147+
func max(a, b int) int {
148+
if a > b {
149+
return a
150+
}
151+
return b
152+
}
153+
154+
func min(a, b int) int {
155+
if a < b {
156+
return a
157+
}
158+
return b
159+
}
67160
```
68161

69162
### **...**

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/Solution.cpp

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
vector<int> numMovesStonesII(vector<int>& stones) {
4+
sort(stones.begin(), stones.end());
5+
int n = stones.size();
6+
int mi = n;
7+
int mx = max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
8+
for (int i = 0, j = 0; j < n; ++j) {
9+
while (stones[j] - stones[i] + 1 > n) {
10+
++i;
11+
}
12+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
13+
mi = min(mi, 2);
14+
} else {
15+
mi = min(mi, n - (j - i + 1));
16+
}
17+
}
18+
return {mi, mx};
19+
}
20+
};

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/Solution.go

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
func numMovesStonesII(stones []int) []int {
2+
sort.Ints(stones)
3+
n := len(stones)
4+
mi := n
5+
mx := max(stones[n-1]-stones[1]+1, stones[n-2]-stones[0]+1) - (n - 1)
6+
i := 0
7+
for j, x := range stones {
8+
for x-stones[i]+1 > n {
9+
i++
10+
}
11+
if j-i+1 == n-1 && stones[j]-stones[i] == n-2 {
12+
mi = min(mi, 2)
13+
} else {
14+
mi = min(mi, n-(j-i+1))
15+
}
16+
}
17+
return []int{mi, mx}
18+
}
19+
20+
func max(a, b int) int {
21+
if a > b {
22+
return a
23+
}
24+
return b
25+
}
26+
27+
func min(a, b int) int {
28+
if a < b {
29+
return a
30+
}
31+
return b
32+
}

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/Solution.java

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public int[] numMovesStonesII(int[] stones) {
3+
Arrays.sort(stones);
4+
int n = stones.length;
5+
int mi = n;
6+
int mx = Math.max(stones[n - 1] - stones[1] + 1, stones[n - 2] - stones[0] + 1) - (n - 1);
7+
for (int i = 0, j = 0; j < n; ++j) {
8+
while (stones[j] - stones[i] + 1 > n) {
9+
++i;
10+
}
11+
if (j - i + 1 == n - 1 && stones[j] - stones[i] == n - 2) {
12+
mi = Math.min(mi, 2);
13+
} else {
14+
mi = Math.min(mi, n - (j - i + 1));
15+
}
16+
}
17+
return new int[] {mi, mx};
18+
}
19+
}

‎solution/1000-1099/1040.Moving Stones Until Consecutive II/Solution.py

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def numMovesStonesII(self, stones: List[int]) -> List[int]:
3+
stones.sort()
4+
mi = n = len(stones)
5+
mx = max(stones[-1] - stones[1] + 1, stones[-2] - stones[0] + 1) - (n - 1)
6+
i = 0
7+
for j, x in enumerate(stones):
8+
while x - stones[i] + 1 > n:
9+
i += 1
10+
if j - i + 1 == n - 1 and x - stones[i] == n - 2:
11+
mi = min(mi, 2)
12+
else:
13+
mi = min(mi, n - (j - i + 1))
14+
return [mi, mx]

0 commit comments

Comments
 (0)