Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit a4afac6

Browse files
yanglbmeyanglbme
authored
feat: update lc problems (doocs#3854)
1 parent 412043e commit a4afac6

File tree

12 files changed

+658
-7
lines changed

12 files changed

+658
-7
lines changed

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/README.md

Lines changed: 77 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -85,25 +85,99 @@ tags:
8585
#### Python3
8686

8787
```python
88-
88+
class Solution:
89+
def maxSubarraySum(self, nums: List[int], k: int) -> int:
90+
f = [inf] * k
91+
ans = -inf
92+
s = f[-1] = 0
93+
for i, x in enumerate(nums):
94+
s += x
95+
ans = max(ans, s - f[i % k])
96+
f[i % k] = min(f[i % k], s)
97+
return ans
8998
```
9099

91100
#### Java
92101

93102
```java
94-
103+
class Solution {
104+
public long maxSubarraySum(int[] nums, int k) {
105+
long[] f = new long[k];
106+
final long inf = 1L << 62;
107+
Arrays.fill(f, inf);
108+
f[k - 1] = 0;
109+
long s = 0;
110+
long ans = -inf;
111+
for (int i = 0; i < nums.length; ++i) {
112+
s += nums[i];
113+
ans = Math.max(ans, s - f[i % k]);
114+
f[i % k] = Math.min(f[i % k], s);
115+
}
116+
return ans;
117+
}
118+
}
95119
```
96120

97121
#### C++
98122

99123
```cpp
100-
124+
class Solution {
125+
public:
126+
long long maxSubarraySum(vector<int>& nums, int k) {
127+
using ll = long long;
128+
ll inf = 1e18;
129+
vector<ll> f(k, inf);
130+
ll ans = -inf;
131+
ll s = 0;
132+
f[k - 1] = 0;
133+
for (int i = 0; i < nums.size(); ++i) {
134+
s += nums[i];
135+
ans = max(ans, s - f[i % k]);
136+
f[i % k] = min(f[i % k], s);
137+
}
138+
return ans;
139+
}
140+
};
101141
```
102142
103143
#### Go
104144
105145
```go
146+
func maxSubarraySum(nums []int, k int) int64 {
147+
inf := int64(1) << 62
148+
f := make([]int64, k)
149+
for i := range f {
150+
f[i] = inf
151+
}
152+
f[k-1] = 0
153+
154+
var s, ans int64
155+
ans = -inf
156+
for i := 0; i < len(nums); i++ {
157+
s += int64(nums[i])
158+
ans = max(ans, s-f[i%k])
159+
f[i%k] = min(f[i%k], s)
160+
}
161+
162+
return ans
163+
}
164+
```
106165

166+
#### TypeScript
167+
168+
```ts
169+
function maxSubarraySum(nums: number[], k: number): number {
170+
const f: number[] = Array(k).fill(Infinity);
171+
f[k - 1] = 0;
172+
let ans = -Infinity;
173+
let s = 0;
174+
for (let i = 0; i < nums.length; ++i) {
175+
s += nums[i];
176+
ans = Math.max(ans, s - f[i % k]);
177+
f[i % k] = Math.min(f[i % k], s);
178+
}
179+
return ans;
180+
}
107181
```
108182

109183
<!-- tabs:end -->

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/README_EN.md

Lines changed: 77 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -82,25 +82,99 @@ tags:
8282
#### Python3
8383

8484
```python
85-
85+
class Solution:
86+
def maxSubarraySum(self, nums: List[int], k: int) -> int:
87+
f = [inf] * k
88+
ans = -inf
89+
s = f[-1] = 0
90+
for i, x in enumerate(nums):
91+
s += x
92+
ans = max(ans, s - f[i % k])
93+
f[i % k] = min(f[i % k], s)
94+
return ans
8695
```
8796

8897
#### Java
8998

9099
```java
91-
100+
class Solution {
101+
public long maxSubarraySum(int[] nums, int k) {
102+
long[] f = new long[k];
103+
final long inf = 1L << 62;
104+
Arrays.fill(f, inf);
105+
f[k - 1] = 0;
106+
long s = 0;
107+
long ans = -inf;
108+
for (int i = 0; i < nums.length; ++i) {
109+
s += nums[i];
110+
ans = Math.max(ans, s - f[i % k]);
111+
f[i % k] = Math.min(f[i % k], s);
112+
}
113+
return ans;
114+
}
115+
}
92116
```
93117

94118
#### C++
95119

96120
```cpp
97-
121+
class Solution {
122+
public:
123+
long long maxSubarraySum(vector<int>& nums, int k) {
124+
using ll = long long;
125+
ll inf = 1e18;
126+
vector<ll> f(k, inf);
127+
ll ans = -inf;
128+
ll s = 0;
129+
f[k - 1] = 0;
130+
for (int i = 0; i < nums.size(); ++i) {
131+
s += nums[i];
132+
ans = max(ans, s - f[i % k]);
133+
f[i % k] = min(f[i % k], s);
134+
}
135+
return ans;
136+
}
137+
};
98138
```
99139
100140
#### Go
101141
102142
```go
143+
func maxSubarraySum(nums []int, k int) int64 {
144+
inf := int64(1) << 62
145+
f := make([]int64, k)
146+
for i := range f {
147+
f[i] = inf
148+
}
149+
f[k-1] = 0
150+
151+
var s, ans int64
152+
ans = -inf
153+
for i := 0; i < len(nums); i++ {
154+
s += int64(nums[i])
155+
ans = max(ans, s-f[i%k])
156+
f[i%k] = min(f[i%k], s)
157+
}
158+
159+
return ans
160+
}
161+
```
103162

163+
#### TypeScript
164+
165+
```ts
166+
function maxSubarraySum(nums: number[], k: number): number {
167+
const f: number[] = Array(k).fill(Infinity);
168+
f[k - 1] = 0;
169+
let ans = -Infinity;
170+
let s = 0;
171+
for (let i = 0; i < nums.length; ++i) {
172+
s += nums[i];
173+
ans = Math.max(ans, s - f[i % k]);
174+
f[i % k] = Math.min(f[i % k], s);
175+
}
176+
return ans;
177+
}
104178
```
105179

106180
<!-- tabs:end -->

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/Solution.cpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution {
2+
public:
3+
long long maxSubarraySum(vector<int>& nums, int k) {
4+
using ll = long long;
5+
ll inf = 1e18;
6+
vector<ll> f(k, inf);
7+
ll ans = -inf;
8+
ll s = 0;
9+
f[k - 1] = 0;
10+
for (int i = 0; i < nums.size(); ++i) {
11+
s += nums[i];
12+
ans = max(ans, s - f[i % k]);
13+
f[i % k] = min(f[i % k], s);
14+
}
15+
return ans;
16+
}
17+
};

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/Solution.go

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
func maxSubarraySum(nums []int, k int) int64 {
2+
inf := int64(1) << 62
3+
f := make([]int64, k)
4+
for i := range f {
5+
f[i] = inf
6+
}
7+
f[k-1] = 0
8+
9+
var s, ans int64
10+
ans = -inf
11+
for i := 0; i < len(nums); i++ {
12+
s += int64(nums[i])
13+
ans = max(ans, s-f[i%k])
14+
f[i%k] = min(f[i%k], s)
15+
}
16+
17+
return ans
18+
}

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/Solution.java

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution {
2+
public long maxSubarraySum(int[] nums, int k) {
3+
long[] f = new long[k];
4+
final long inf = 1L << 62;
5+
Arrays.fill(f, inf);
6+
f[k - 1] = 0;
7+
long s = 0;
8+
long ans = -inf;
9+
for (int i = 0; i < nums.length; ++i) {
10+
s += nums[i];
11+
ans = Math.max(ans, s - f[i % k]);
12+
f[i % k] = Math.min(f[i % k], s);
13+
}
14+
return ans;
15+
}
16+
}

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/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 maxSubarraySum(self, nums: List[int], k: int) -> int:
3+
f = [inf] * k
4+
ans = -inf
5+
s = f[-1] = 0
6+
for i, x in enumerate(nums):
7+
s += x
8+
ans = max(ans, s - f[i % k])
9+
f[i % k] = min(f[i % k], s)
10+
return ans

‎solution/3300-3399/3381.Maximum Subarray Sum With Length Divisible by K/Solution.ts

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,12 @@
1+
function maxSubarraySum(nums: number[], k: number): number {
2+
const f: number[] = Array(k).fill(Infinity);
3+
f[k - 1] = 0;
4+
let ans = -Infinity;
5+
let s = 0;
6+
for (let i = 0; i < nums.length; ++i) {
7+
s += nums[i];
8+
ans = Math.max(ans, s - f[i % k]);
9+
f[i % k] = Math.min(f[i % k], s);
10+
}
11+
return ans;
12+
}

‎solution/3300-3399/3384.Team Dominance by Pass Success/README_EN.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@ tags:
2323
| Column Name | Type |
2424
+-------------+---------+
2525
| player_id | int |
26-
| team_name | varchar |
26+
| team_name | varchar |
2727
+-------------+---------+
2828
player_id is the unique key for this table.
2929
Each row contains the unique identifier for player and the name of one of the teams participating in that match.

0 commit comments

Comments
 (0)