Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 7e08c19

Browse files
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 {
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)

AltStyle によって変換されたページ (->オリジナル) /