Movatterモバイル変換

[0]ホーム
URL:

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

Commit0835de8

Browse files
committed
Updated 3 md files.
1 parent2cdd9b1 commit0835de8

6 files changed

+90
-81
lines changed

‎en/1-1000/209-minimum-size-subarray-sum.md

Lines changed: 36 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -29,45 +29,48 @@ Given an array of positive integers `nums` and a positive integer `target`, retu
2929
-`1 <= nums[i] <= 10000`
3030

3131
##Intuition
32-
For**subarray** problems, you can consider using**Sliding Window Technique**, which is similar to the**Fastand Slow PointersTechnique**.
32+
For**subarray** problems, you can consider using**Sliding Window Technique**, which is similar to the**Fast& Slow PointersApproach**.
3333

3434
##Steps
35-
1. Iterate over the`nums` array, the`index` of the element is named`fastIndex`. Although inconspicuous, this is the most important logic of the_Fast and Slow Pointers Technique_. Please memorize it.
36-
2.`sum += nums[fast_index]`.
37-
```java
38-
var minLength=Integer.MAX_VALUE;
39-
var sum=0;
40-
var slowIndex=0;
41-
42-
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// This line the most important logic of the `Fast and Slow Pointers Technique`.
43-
sum+= nums[fastIndex];// 1
44-
}
45-
46-
return minLength;
47-
```
48-
49-
3. Control of`slowIndex`:
50-
```java
51-
var minLength=Integer.MAX_VALUE;
52-
var sum=0;
53-
var slowIndex=0;
35+
1. Iterate over the`nums` array, the`index` of the element is named`fastIndex`. Although inconspicuous, this is the most important logic of the*Fast & Slow Pointers Approach*. Please memorize it.
5436

55-
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {
56-
sum+= nums[fastIndex];
37+
2.`sum += nums[fast_index]`.
5738

58-
while (sum>= target) {// 1
59-
minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2
60-
sum-= nums[slowIndex];// 3
61-
slowIndex++;// 4
39+
```java
40+
var minLength=Integer.MAX_VALUE;
41+
var sum=0;
42+
var slowIndex=0;
43+
44+
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// This line the most important logic of the `Fast and Slow Pointers Technique`.
45+
sum+= nums[fastIndex];// 1
6246
}
63-
}
47+
48+
return minLength;
49+
```
6450

65-
if (minLength==Integer.MAX_VALUE) {// 5
66-
return0;// 6
67-
}
51+
3.Control of `slowIndex`:
6852

69-
return minLength;
70-
```
53+
```java
54+
var minLength=Integer.MAX_VALUE;
55+
var sum=0;
56+
var slowIndex=0;
57+
58+
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {
59+
sum+= nums[fastIndex];
60+
61+
while (sum>= target) {// 1
62+
minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2
63+
sum-= nums[slowIndex];// 3
64+
slowIndex++;// 4
65+
}
66+
}
67+
68+
if (minLength==Integer.MAX_VALUE) {// 5
69+
return0;// 6
70+
}
71+
72+
return minLength;
73+
```
7174

7275
##Complexity
7376
*Time: `O(n)`.
@@ -129,7 +132,7 @@ class Solution:
129132

130133
##JavaScript
131134
```javascript
132-
varminSubArrayLen=function(target,nums) {
135+
varminSubArrayLen=function(target,nums) {
133136
let minLength=Number.MAX_SAFE_INTEGER
134137
let sum=0
135138
let slowIndex=0

‎en/1-1000/59-spiral-matrix-ii.md

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -27,12 +27,14 @@ Output: [[1]]
2727

2828
##Steps to the Solution
2929
1. Initialize`increments` and`increment_index`:
30+
3031
```python
3132
increments= [(0,1), (1,0), (0,-1), (-1,0)]# (i, j) right, down, left, up
3233
increment_index=0
3334
```
3435

3536
2. Core logic:
37+
3638
```python
3739
while num<= n* n:
3840
matrix[i][j]= num
@@ -44,20 +46,21 @@ Output: [[1]]
4446
```
4547

4648
3. For function`get_increment(i, j)`, it shouldreturn a pair like`[0,1]`. First verify whether the current incrementis valid. Ifnot, use thenext increment.
49+
4750
```python
4851
defget_increment(i,j):
4952
increment= increments[increment_index]
5053
i+= increment[0]
5154
j+= increment[1]
52-
55+
5356
if (
5457
i<0or i>=len(matrix)or
5558
j<0or j>=len(matrix)or
5659
matrix[i][j]isnotNone
5760
):# not valid, use next increment
5861
increment_index+=1
5962
increment_index%=len(self.increments)
60-
63+
6164
return increments[increment_index]
6265
```
6366

‎en/1-1000/977-squares-of-a-sorted-array.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22
LeetCode link:[977. Squares of a Sorted Array](https://leetcode.com/problems/squares-of-a-sorted-array)
33

44
##LeetCode problem description
5-
Given an integer array`nums` sorted in**non-decreasing** order, return_an array of**the squares of each number**sorted in non-decreasing order._
5+
Given an integer array`nums` sorted in**non-decreasing** order, return*an array of****the squares of each number****sorted in non-decreasing order.*
66

77
###Example 1
88
```ruby

‎zh/1-1000/209-minimum-size-subarray-sum.md

Lines changed: 34 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -31,46 +31,49 @@
3131
-`1 <= nums[i] <= 10000`
3232

3333
##思路
34-
1. 对于**子数组**问题，可以考虑使用**滑动窗口技术**，它类似于**快速和慢速指针技术**。
34+
1. 对于**子数组**问题，可以考虑使用**滑动窗口技术**，它类似于**快慢双指针方法**。
3535

3636

3737
##步骤
3838
1.**遍历**`nums` 数组，元素的`index` 可命名为`fastIndex`。虽然不起眼，但这是`快慢指针技术`**最重要**的逻辑。请最好记住它。
39-
2.`sum += nums[fast_index]`.
40-
```java
41-
var minLength=Integer.MAX_VALUE;
42-
var sum=0;
43-
var slowIndex=0;
44-
45-
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// 本行是`快慢指针技术`最重要的逻辑
46-
sum+= nums[fastIndex];// 1
47-
}
48-
49-
return minLength;
50-
```
51-
52-
3. 控制`slowIndex`。
53-
```java
54-
var minLength=Integer.MAX_VALUE;
55-
var sum=0;
56-
var slowIndex=0;
5739

58-
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {
59-
sum+= nums[fastIndex];
40+
2.`sum += nums[fast_index]`.
6041

61-
while (sum>= target) {// 1
62-
minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2
63-
sum-= nums[slowIndex];// 3
64-
slowIndex++;// 4
42+
```java
43+
var minLength=Integer.MAX_VALUE;
44+
var sum=0;
45+
var slowIndex=0;
46+
47+
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// 本行是`快慢指针技术`最重要的逻辑
48+
sum+= nums[fastIndex];// 1
6549
}
66-
}
50+
51+
return minLength;
52+
```
6753

68-
if (minLength==Integer.MAX_VALUE) {// 5
69-
return0;// 6
70-
}
54+
3. 控制`slowIndex`。
7155

72-
return minLength;
73-
```
56+
```java
57+
var minLength=Integer.MAX_VALUE;
58+
var sum=0;
59+
var slowIndex=0;
60+
61+
for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {
62+
sum+= nums[fastIndex];
63+
64+
while (sum>= target) {// 1
65+
minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2
66+
sum-= nums[slowIndex];// 3
67+
slowIndex++;// 4
68+
}
69+
}
70+
71+
if (minLength==Integer.MAX_VALUE) {// 5
72+
return0;// 6
73+
}
74+
75+
return minLength;
76+
```
7477

7578
## 复杂度
7679
* 时间: `O(n)`.

‎zh/1-1000/59-spiral-matrix-ii.md

Lines changed: 10 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -26,13 +26,15 @@ Output: [[1]]
2626
* You only need to use a`get_increment(i, j)` function to specifically control the index of the next two-dimensional array.
2727

2828
##Steps to the Solution
29-
1. Initialize`increments` and`increment_index`:
29+
1. 初始化`increments` 和`increment_index`:
30+
3031
```python
3132
increments= [(0,1), (1,0), (0,-1), (-1,0)]# (i, j) right, down, left, up
3233
increment_index=0
3334
```
3435

35-
2. Core logic:
36+
2. 核心逻辑:
37+
3638
```python
3739
while num<= n* n:
3840
matrix[i][j]= num
@@ -43,9 +45,10 @@ Output: [[1]]
4345
j+= increment[1]
4446
```
4547

46-
3. For function`get_increment(i, j)`, it shouldreturn a pair like`[0,1]`. First verify whether the current incrementis valid. Ifnot, use thenext increment.
47-
```python
48-
defget_increment(i,j):
48+
3. 对于函数`get_increment(i, j)`，它应该返回一对`[0,1]`。首先验证当前增量是否有效。如果无效，则使用下一个增量。
49+
50+
```python
51+
defget_increment(i,j):
4952
increment= increments[increment_index]
5053
i+= increment[0]
5154
j+= increment[1]
@@ -54,12 +57,12 @@ Output: [[1]]
5457
i<0or i>=len(matrix)or
5558
j<0or j>=len(matrix)or
5659
matrix[i][j]isnotNone
57-
):#not valid, use next increment
60+
):#当前增量无效，使用下一个增量
5861
increment_index+=1
5962
increment_index%=len(self.increments)
6063

6164
return increments[increment_index]
62-
```
65+
```
6366

6467
## Complexity
6568
* Time:`O(n* n)`.

‎zh/1-1000/704-binary-search.md

Lines changed: 4 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,9 +2,7 @@
22
LeetCode link:[704. Binary Search](https://leetcode.com/problems/binary-search)
33

44
##LeetCode problem description
5-
Given an array of integers`nums` which is sorted in ascending order, and an integer`target`, write a function to search`target` in`nums`. If`target` exists, then return its`index`. Otherwise, return`-1`.
6-
7-
You must write an algorithm with`O(log n)` runtime complexity.
5+
给定一个`n` 个元素有序的（升序）整型数组`nums` 和一个目标值`target` ，写一个函数搜索`nums` 中的`target`，如果目标值存在返回下标，否则返回`-1`。
86

97
###Example 1
108
```ruby
@@ -21,10 +19,9 @@ Explanation: 2 does not exist in nums so return -1
2119
```
2220

2321
###Constraints
24-
-`1 <= nums.length <= 10000`
25-
-`104 < nums[i], target < 10000`
26-
- All the integers in`nums` are**unique**.
27-
-`nums` is sorted in ascending order.
22+
- 你可以假设`nums` 中的所有元素是不重复的。
23+
-`n` 将在`[1, 10000]` 之间。
24+
-`nums` 的每个元素都将在`[-9999, 9999]` 之间。
2825

2926
##Intuition
3027
Because it is an already sorted array, by using the middle value for comparison, half of the numbers can be eliminated each time.

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp