feat: update lc problems

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

@@ -85,25 +85,99 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def maxSubarraySum(self, nums: List[int], k: int) -> int:
+        f = [inf] * k
+        ans = -inf
+        s = f[-1] = 0
+        for i, x in enumerate(nums):
+            s += x
+            ans = max(ans, s - f[i % k])
+            f[i % k] = min(f[i % k], s)
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long maxSubarraySum(int[] nums, int k) {
+        long[] f = new long[k];
+        final long inf = 1L << 62;
+        Arrays.fill(f, inf);
+        f[k - 1] = 0;
+        long s = 0;
+        long ans = -inf;
+        for (int i = 0; i < nums.length; ++i) {
+            s += nums[i];
+            ans = Math.max(ans, s - f[i % k]);
+            f[i % k] = Math.min(f[i % k], s);
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maxSubarraySum(vector<int>& nums, int k) {
+        using ll = long long;
+        ll inf = 1e18;
+        vector<ll> f(k, inf);
+        ll ans = -inf;
+        ll s = 0;
+        f[k - 1] = 0;
+        for (int i = 0; i < nums.size(); ++i) {
+            s += nums[i];
+            ans = max(ans, s - f[i % k]);
+            f[i % k] = min(f[i % k], s);
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maxSubarraySum(nums []int, k int) int64 {
+	inf := int64(1) << 62
+	f := make([]int64, k)
+	for i := range f {
+		f[i] = inf
+	}
+	f[k-1] = 0
+
+	var s, ans int64
+	ans = -inf
+	for i := 0; i < len(nums); i++ {
+		s += int64(nums[i])
+		ans = max(ans, s-f[i%k])
+		f[i%k] = min(f[i%k], s)
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function maxSubarraySum(nums: number[], k: number): number {
+    const f: number[] = Array(k).fill(Infinity);
+    f[k - 1] = 0;
+    let ans = -Infinity;
+    let s = 0;
+    for (let i = 0; i < nums.length; ++i) {
+        s += nums[i];
+        ans = Math.max(ans, s - f[i % k]);
+        f[i % k] = Math.min(f[i % k], s);
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

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

@@ -82,25 +82,99 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def maxSubarraySum(self, nums: List[int], k: int) -> int:
+        f = [inf] * k
+        ans = -inf
+        s = f[-1] = 0
+        for i, x in enumerate(nums):
+            s += x
+            ans = max(ans, s - f[i % k])
+            f[i % k] = min(f[i % k], s)
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long maxSubarraySum(int[] nums, int k) {
+        long[] f = new long[k];
+        final long inf = 1L << 62;
+        Arrays.fill(f, inf);
+        f[k - 1] = 0;
+        long s = 0;
+        long ans = -inf;
+        for (int i = 0; i < nums.length; ++i) {
+            s += nums[i];
+            ans = Math.max(ans, s - f[i % k]);
+            f[i % k] = Math.min(f[i % k], s);
+        }
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maxSubarraySum(vector<int>& nums, int k) {
+        using ll = long long;
+        ll inf = 1e18;
+        vector<ll> f(k, inf);
+        ll ans = -inf;
+        ll s = 0;
+        f[k - 1] = 0;
+        for (int i = 0; i < nums.size(); ++i) {
+            s += nums[i];
+            ans = max(ans, s - f[i % k]);
+            f[i % k] = min(f[i % k], s);
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maxSubarraySum(nums []int, k int) int64 {
+	inf := int64(1) << 62
+	f := make([]int64, k)
+	for i := range f {
+		f[i] = inf
+	}
+	f[k-1] = 0
+
+	var s, ans int64
+	ans = -inf
+	for i := 0; i < len(nums); i++ {
+		s += int64(nums[i])
+		ans = max(ans, s-f[i%k])
+		f[i%k] = min(f[i%k], s)
+	}
+
+	return ans
+}
+```
 
+#### TypeScript
+
+```ts
+function maxSubarraySum(nums: number[], k: number): number {
+    const f: number[] = Array(k).fill(Infinity);
+    f[k - 1] = 0;
+    let ans = -Infinity;
+    let s = 0;
+    for (let i = 0; i < nums.length; ++i) {
+        s += nums[i];
+        ans = Math.max(ans, s - f[i % k]);
+        f[i % k] = Math.min(f[i % k], s);
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->

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

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    long long maxSubarraySum(vector<int>& nums, int k) {
+        using ll = long long;
+        ll inf = 1e18;
+        vector<ll> f(k, inf);
+        ll ans = -inf;
+        ll s = 0;
+        f[k - 1] = 0;
+        for (int i = 0; i < nums.size(); ++i) {
+            s += nums[i];
+            ans = max(ans, s - f[i % k]);
+            f[i % k] = min(f[i % k], s);
+        }
+        return ans;
+    }
+};

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

@@ -0,0 +1,18 @@
+func maxSubarraySum(nums []int, k int) int64 {
+	inf := int64(1) << 62
+	f := make([]int64, k)
+	for i := range f {
+		f[i] = inf
+	}
+	f[k-1] = 0
+
+	var s, ans int64
+	ans = -inf
+	for i := 0; i < len(nums); i++ {
+		s += int64(nums[i])
+		ans = max(ans, s-f[i%k])
+		f[i%k] = min(f[i%k], s)
+	}
+
+	return ans
+}

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

@@ -0,0 +1,16 @@
+class Solution {
+    public long maxSubarraySum(int[] nums, int k) {
+        long[] f = new long[k];
+        final long inf = 1L << 62;
+        Arrays.fill(f, inf);
+        f[k - 1] = 0;
+        long s = 0;
+        long ans = -inf;
+        for (int i = 0; i < nums.length; ++i) {
+            s += nums[i];
+            ans = Math.max(ans, s - f[i % k]);
+            f[i % k] = Math.min(f[i % k], s);
+        }
+        return ans;
+    }
+}

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

@@ -0,0 +1,10 @@
+class Solution:
+    def maxSubarraySum(self, nums: List[int], k: int) -> int:
+        f = [inf] * k
+        ans = -inf
+        s = f[-1] = 0
+        for i, x in enumerate(nums):
+            s += x
+            ans = max(ans, s - f[i % k])
+            f[i % k] = min(f[i % k], s)
+        return ans

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

@@ -0,0 +1,12 @@
+function maxSubarraySum(nums: number[], k: number): number {
+    const f: number[] = Array(k).fill(Infinity);
+    f[k - 1] = 0;
+    let ans = -Infinity;
+    let s = 0;
+    for (let i = 0; i < nums.length; ++i) {
+        s += nums[i];
+        ans = Math.max(ans, s - f[i % k]);
+        f[i % k] = Math.min(f[i % k], s);
+    }
+    return ans;
+}

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

@@ -23,7 +23,7 @@ tags:
 | Column Name | Type    |
 +-------------+---------+
 | player_id   | int     |
-| team_name   | varchar |
+| team_name   | varchar | 
 +-------------+---------+
 player_id is the unique key for this table.
 Each row contains the unique identifier for player and the name of one of the teams participating in that match.