Skip to content

Commit 7e08c19

Browse files
YangFongYangFong
committed
feat: update solutions to lc problems: No.0209,0744
- No.0209.Minimum Size Subarray Sum - No.0744.Find Smallest Letter Greater Than Target
1 parent 731f2d3 commit 7e08c19

File tree

9 files changed

+105
-142
lines changed

9 files changed

+105
-142
lines changed

‎solution/0200-0299/0209.Minimum Size Subarray Sum/README.md

Lines changed: 19 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -60,13 +60,13 @@
6060

6161
先求出数组的前缀和 `s`，然后根据 `s[j] - s[i] >= target` => `s[j] >= s[i] + target`，找出最小的一个 j，使得 `s[j]` 满足大于等于 `s[i] + target`，然后更新最小长度即可。
6262

63-
时间复杂度 `O(n logn)`。
63+
时间复杂度 $O(NlogN)$。
6464

6565
**方法二：滑动窗口**
6666

67-
使用指针 left, right 分别表示子数组的开始位置和结束位置，维护变量 sum 表示子数组 `nums[left...right]` 元素之和。初始时 left, right 均指向 0。每一次迭代，将 `nums[right]` 加到 sum，如果此时 `sum >= target`，更新最小长度即可。然后将 sum 减去 `nums[left]`，接着 left 指针右移直至 `sum < target`。每一次迭代最后，将 right 指针右移。
67+
使用指针 `left`, `right` 分别表示子数组的开始位置和结束位置，维护变量 `sum` 表示子数组 `nums[left...right]` 元素之和。初始时 `left`, `right` 均指向 0。每一次迭代，将 `nums[right]` 加到 `sum`，如果此时 `sum >= target`，更新最小长度即可。然后将 `sum` 减去 `nums[left]`，接着 `left` 指针右移直至 `sum < target`。每一次迭代最后，将 `right` 指针右移。
6868

69-
时间复杂度 `O(n)`。
69+
时间复杂度 $O(N)$。
7070

7171
<!-- tabs:start -->
7272

@@ -278,21 +278,22 @@ public class Solution {
278278
```ts
279279
function minSubArrayLen(target: number, nums: number[]): number {
280280
const n = nums.length;
281-
let res = Infinity;
281+
let res = n + 1;
282282
let sum = 0;
283283
let i = 0;
284-
let j = 0;
285-
while (j <= n) {
286-
if (sum < target) {
287-
sum += nums[j];
288-
j++;
289-
} else {
290-
res = Math.min(res, j - i);
284+
for (let j = 0; j < n; j++) {
285+
sum += nums[j];
286+
while (sum >= target) {
287+
res = Math.min(res, j - i + 1);
291288
sum -= nums[i];
292289
i++;
293290
}
294291
}
295-
return res === Infinity ? 0 : res;
292+
293+
if (res === n + 1) {
294+
return 0;
295+
}
296+
return res;
296297
}
297298
```
298299

@@ -304,14 +305,14 @@ impl Solution {
304305
let n = nums.len();
305306
let mut res = n + 1;
306307
let mut sum = 0;
307-
let mut l = 0;
308-
for r in 0..n {
309-
sum += nums[r];
308+
let mut i = 0;
309+
for j in 0..n {
310+
sum += nums[j];
310311

311312
while sum >= target {
312-
res = res.min(r - l + 1);
313-
sum -= nums[l];
314-
l += 1;
313+
res = res.min(j - i + 1);
314+
sum -= nums[i];
315+
i += 1;
315316
}
316317
}
317318
if res == n + 1 {

‎solution/0200-0299/0209.Minimum Size Subarray Sum/README_EN.md

Lines changed: 16 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -253,21 +253,22 @@ public class Solution {
253253
```ts
254254
function minSubArrayLen(target: number, nums: number[]): number {
255255
const n = nums.length;
256-
let res = Infinity;
256+
let res = n + 1;
257257
let sum = 0;
258258
let i = 0;
259-
let j = 0;
260-
while (j <= n) {
261-
if (sum < target) {
262-
sum += nums[j];
263-
j++;
264-
} else {
265-
res = Math.min(res, j - i);
259+
for (let j = 0; j < n; j++) {
260+
sum += nums[j];
261+
while (sum >= target) {
262+
res = Math.min(res, j - i + 1);
266263
sum -= nums[i];
267264
i++;
268265
}
269266
}
270-
return res === Infinity ? 0 : res;
267+
268+
if (res === n + 1) {
269+
return 0;
270+
}
271+
return res;
271272
}
272273
```
273274

@@ -279,14 +280,14 @@ impl Solution {
279280
let n = nums.len();
280281
let mut res = n + 1;
281282
let mut sum = 0;
282-
let mut l = 0;
283-
for r in 0..n {
284-
sum += nums[r];
283+
let mut i = 0;
284+
for j in 0..n {
285+
sum += nums[j];
285286

286287
while sum >= target {
287-
res = res.min(r - l + 1);
288-
sum -= nums[l];
289-
l += 1;
288+
res = res.min(j - i + 1);
289+
sum -= nums[i];
290+
i += 1;
290291
}
291292
}
292293
if res == n + 1 {

‎solution/0200-0299/0209.Minimum Size Subarray Sum/Solution.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,14 +3,14 @@ impl Solution {
33
let n = nums.len();
44
let mut res = n + 1;
55
let mut sum = 0;
6-
let mut l = 0;
7-
for r in 0..n {
8-
sum += nums[r];
6+
let mut i = 0;
7+
for j in 0..n {
8+
sum += nums[j];
99

1010
while sum >= target {
11-
res = res.min(r - l + 1);
12-
sum -= nums[l];
13-
l += 1;
11+
res = res.min(j - i + 1);
12+
sum -= nums[i];
13+
i += 1;
1414
}
1515
}
1616
if res == n + 1 {

‎solution/0200-0299/0209.Minimum Size Subarray Sum/Solution.ts

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,19 @@
11
function minSubArrayLen(target: number, nums: number[]): number {
22
const n = nums.length;
3-
let res = Infinity;
3+
let res = n + 1;
44
let sum = 0;
55
let i = 0;
6-
let j = 0;
7-
while (j <= n) {
8-
if (sum < target) {
9-
sum += nums[j];
10-
j++;
11-
} else {
12-
res = Math.min(res, j - i);
6+
for (let j = 0; j < n; j++) {
7+
sum += nums[j];
8+
while (sum >= target) {
9+
res = Math.min(res, j - i + 1);
1310
sum -= nums[i];
1411
i++;
1512
}
1613
}
17-
return res === Infinity ? 0 : res;
14+
15+
if (res === n + 1) {
16+
return 0;
17+
}
18+
return res;
1819
}

‎solution/0700-0799/0713.Subarray Product Less Than K/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,7 +52,7 @@ for (int i = 0, j = 0; i < n; ++i) {
5252
}
5353
```
5454

55-
时间复杂度 O(n)。
55+
时间复杂度：$O(n)$。
5656

5757
<!-- tabs:start -->
5858

‎solution/0700-0799/0744.Find Smallest Letter Greater Than Target/README.md

Lines changed: 24 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -53,17 +53,19 @@
5353

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

56-
方法一：遍历
56+
**方法一：遍历**
5757

58-
遍历 `letters`，返回第一个满足 `letters[i] > target` 条件的元素。若是遍历结束还未找到，则返回 `letters[0]`
58+
遍历 `letters`，返回第一个满足 `letters[i] > target` 条件的元素。若是遍历结束还未找到，则返回 `letters[0]`。
5959

60-
> 至少存在两个不同的字母，所以不会返回 `target`
60+
> 至少存在两个不同的字母，所以不会返回 `target`。
6161
62-
方法二：二分
62+
时间复杂度：$O(N)$。
63+
64+
**方法二：二分**
6365

6466
利用 `letters` 有序的特点，可以使用二分来快速查找。
6567

66-
在返回值方面相比传统二分不一样，需要对结果进行取余操作：`letters[l % letters.length]`
68+
在返回值方面相比传统二分不一样，需要对结果进行取余操作：`letters[l % n]`。
6769

6870
为什么？如题描述，字母是重复出现的，当索引过界时，不是没有结果，而是需要返回前面的元素。
6971

@@ -76,6 +78,8 @@ if (l < n) {
7678
return letters[l - n];
7779
```
7880

81+
时间复杂度：$O(logN)$。
82+
7983
<!-- tabs:start -->
8084

8185
### **Python3**
@@ -120,35 +124,18 @@ class Solution {
120124

121125
```ts
122126
function nextGreatestLetter(letters: string[], target: string): string {
123-
let left = 0,
124-
right = letters.length;
125-
let x = target.charCodeAt(0);
127+
const n = letters.length;
128+
let left = 0;
129+
let right = letters.length;
126130
while (left < right) {
127-
let mid = (left + right) >> 1;
128-
if (x < letters[mid].charCodeAt(0)) {
131+
let mid = (left + right) >>> 1;
132+
if (letters[mid] > target) {
129133
right = mid;
130134
} else {
131135
left = mid + 1;
132136
}
133137
}
134-
return letters[left % letters.length];
135-
}
136-
```
137-
138-
```ts
139-
function nextGreatestLetter(letters: string[], target: string): string {
140-
const n = letters.length;
141-
let l = 0;
142-
let r = n;
143-
while (l < r) {
144-
const mid = (l + r) >>> 1;
145-
if (target < letters[mid]) {
146-
r = mid;
147-
} else {
148-
l = mid + 1;
149-
}
150-
}
151-
return letters[l % n];
138+
return letters[left % n];
152139
}
153140
```
154141

@@ -194,12 +181,7 @@ func nextGreatestLetter(letters []byte, target byte) byte {
194181
```rust
195182
impl Solution {
196183
pub fn next_greatest_letter(letters: Vec<char>, target: char) -> char {
197-
for c in letters.iter() {
198-
if c > &target {
199-
return *c;
200-
}
201-
}
202-
letters[0]
184+
*letters.iter().find(|&&c| c > target).unwrap_or(&letters[0])
203185
}
204186
}
205187
```
@@ -208,17 +190,17 @@ impl Solution {
208190
impl Solution {
209191
pub fn next_greatest_letter(letters: Vec<char>, target: char) -> char {
210192
let n = letters.len();
211-
let mut l = 0;
212-
let mut r = n;
213-
while l < r {
214-
let mid = l + r >> 1;
215-
if letters[mid] <= target {
216-
l = mid + 1;
193+
let mut left = 0;
194+
let mut right = n;
195+
while left < right {
196+
let mid = left + (right - left) / 2;
197+
if letters[mid] > target {
198+
right = mid;
217199
} else {
218-
r = mid;
200+
left = mid + 1;
219201
}
220202
}
221-
letters[l % n]
203+
letters[left % n]
222204
}
223205
}
224206
```

‎solution/0700-0799/0744.Find Smallest Letter Greater Than Target/README_EN.md

Lines changed: 15 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -87,35 +87,18 @@ class Solution {
8787

8888
```ts
8989
function nextGreatestLetter(letters: string[], target: string): string {
90-
let left = 0,
91-
right = letters.length;
92-
let x = target.charCodeAt(0);
90+
const n = letters.length;
91+
let left = 0;
92+
let right = letters.length;
9393
while (left < right) {
94-
let mid = (left + right) >> 1;
95-
if (x < letters[mid].charCodeAt(0)) {
94+
let mid = (left + right) >>> 1;
95+
if (letters[mid] > target) {
9696
right = mid;
9797
} else {
9898
left = mid + 1;
9999
}
100100
}
101-
return letters[left % letters.length];
102-
}
103-
```
104-
105-
```ts
106-
function nextGreatestLetter(letters: string[], target: string): string {
107-
const n = letters.length;
108-
let l = 0;
109-
let r = n;
110-
while (l < r) {
111-
const mid = (l + r) >>> 1;
112-
if (target < letters[mid]) {
113-
r = mid;
114-
} else {
115-
l = mid + 1;
116-
}
117-
}
118-
return letters[l % n];
101+
return letters[left % n];
119102
}
120103
```
121104

@@ -161,12 +144,7 @@ func nextGreatestLetter(letters []byte, target byte) byte {
161144
```rust
162145
impl Solution {
163146
pub fn next_greatest_letter(letters: Vec<char>, target: char) -> char {
164-
for c in letters.iter() {
165-
if c > &target {
166-
return *c;
167-
}
168-
}
169-
letters[0]
147+
*letters.iter().find(|&&c| c > target).unwrap_or(&letters[0])
170148
}
171149
}
172150
```
@@ -175,17 +153,17 @@ impl Solution {
175153
impl Solution {
176154
pub fn next_greatest_letter(letters: Vec<char>, target: char) -> char {
177155
let n = letters.len();
178-
let mut l = 0;
179-
let mut r = n;
180-
while l < r {
181-
let mid = l + r >> 1;
182-
if letters[mid] <= target {
183-
l = mid + 1;
156+
let mut left = 0;
157+
let mut right = n;
158+
while left < right {
159+
let mid = left + (right - left) / 2;
160+
if letters[mid] > target {
161+
right = mid;
184162
} else {
185-
r = mid;
163+
left = mid + 1;
186164
}
187165
}
188-
letters[l % n]
166+
letters[left % n]
189167
}
190168
}
191169
```

0 commit comments

Comments
 (0)