feat: add solutions to lc problem: No.2270

No.2270.Number of Ways to Split Array

Author: yanglbme

solution/2200-2299/2270.Number of Ways to Split Array/README.md

@@ -55,6 +55,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：前缀和**
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -64,14 +66,13 @@
 ```python
 class Solution:
     def waysToSplitArray(self, nums: List[int]) -> int:
-        left, right = 0, sum(nums)
-        cnt = 0
+        s = sum(nums)
+        ans = t = 0
         for v in nums[:-1]:
-            left += v
-            right -= v
-            if left >= right:
-                cnt += 1
-        return cnt
+            t += v
+            if t >= s - t:
+                ans += 1
+        return ans
 ```
 
 ### **Java**
@@ -81,18 +82,58 @@ class Solution:
 ```java
 class Solution {
     public int waysToSplitArray(int[] nums) {
-        long[] pre = new long[nums.length + 1];
-        for (int i = 0; i < nums.length; i++) {
-            pre[i + 1] = pre[i] + nums[i];
+        long s = 0;
+        for (int v : nums) {
+            s += v;
         }
-        int cnt = 0;
-        for (int i = 1; i < nums.length; i++) {
-            if (pre[i] >= pre[nums.length] - pre[i]) {
-                cnt++;
+        int ans = 0;
+        long t = 0;
+        for (int i = 0; i < nums.length - 1; ++i) {
+            t += nums[i];
+            if (t >= s - t) {
+                ++ans;
             }
         }
-        return cnt;
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int waysToSplitArray(vector<int>& nums) {
+        long long s = accumulate(nums.begin(), nums.end(), 0ll);
+        long long t = 0;
+        int ans = 0;
+        for (int i = 0; i < nums.size() - 1; ++i)
+        {
+            t += nums[i];
+            ans += t >= s - t;
+        }
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func waysToSplitArray(nums []int) int {
+	s := 0
+	for _, v := range nums {
+		s += v
+	}
+	ans, t := 0, 0
+	for _, v := range nums[:len(nums)-1] {
+		t += v
+		if t >= s-t {
+			ans++
+		}
+	}
+	return ans
 }
 ```
 

solution/2200-2299/2270.Number of Ways to Split Array/README_EN.md

@@ -57,36 +57,75 @@ There are two valid splits in nums:
 ```python
 class Solution:
     def waysToSplitArray(self, nums: List[int]) -> int:
-        left, right = 0, sum(nums)
-        cnt = 0
+        s = sum(nums)
+        ans = t = 0
         for v in nums[:-1]:
-            left += v
-            right -= v
-            if left >= right:
-                cnt += 1
-        return cnt
+            t += v
+            if t >= s - t:
+                ans += 1
+        return ans
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int waysToSplitArray(int[] nums) {
-        long[] pre = new long[nums.length + 1];
-        for (int i = 0; i < nums.length; i++) {
-            pre[i + 1] = pre[i] + nums[i];
+        long s = 0;
+        for (int v : nums) {
+            s += v;
         }
-        int cnt = 0;
-        for (int i = 1; i < nums.length; i++) {
-            if (pre[i] >= pre[nums.length] - pre[i]) {
-                cnt++;
+        int ans = 0;
+        long t = 0;
+        for (int i = 0; i < nums.length - 1; ++i) {
+            t += nums[i];
+            if (t >= s - t) {
+                ++ans;
             }
         }
-        return cnt;
+        return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int waysToSplitArray(vector<int>& nums) {
+        long long s = accumulate(nums.begin(), nums.end(), 0ll);
+        long long t = 0;
+        int ans = 0;
+        for (int i = 0; i < nums.size() - 1; ++i)
+        {
+            t += nums[i];
+            ans += t >= s - t;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func waysToSplitArray(nums []int) int {
+	s := 0
+	for _, v := range nums {
+		s += v
+	}
+	ans, t := 0, 0
+	for _, v := range nums[:len(nums)-1] {
+		t += v
+		if t >= s-t {
+			ans++
+		}
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts

solution/2200-2299/2270.Number of Ways to Split Array/Solution.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int waysToSplitArray(vector<int>& nums) {
+        long long s = accumulate(nums.begin(), nums.end(), 0ll);
+        long long t = 0;
+        int ans = 0;
+        for (int i = 0; i < nums.size() - 1; ++i)
+        {
+            t += nums[i];
+            ans += t >= s - t;
+        }
+        return ans;
+    }
+};

solution/2200-2299/2270.Number of Ways to Split Array/Solution.go

@@ -0,0 +1,14 @@
+func waysToSplitArray(nums []int) int {
+	s := 0
+	for _, v := range nums {
+		s += v
+	}
+	ans, t := 0, 0
+	for _, v := range nums[:len(nums)-1] {
+		t += v
+		if t >= s-t {
+			ans++
+		}
+	}
+	return ans
+}

solution/2200-2299/2270.Number of Ways to Split Array/Solution.java

@@ -1,15 +1,17 @@
 class Solution {
     public int waysToSplitArray(int[] nums) {
-        long[] pre = new long[nums.length + 1];
-        for (int i = 0; i < nums.length; i++) {
-            pre[i + 1] = pre[i] + nums[i];
+        long s = 0;
+        for (int v : nums) {
+            s += v;
         }
-        int cnt = 0;
-        for (int i = 1; i < nums.length; i++) {
-            if (pre[i] >= pre[nums.length] - pre[i]) {
-                cnt++;
+        int ans = 0;
+        long t = 0;
+        for (int i = 0; i < nums.length - 1; ++i) {
+            t += nums[i];
+            if (t >= s - t) {
+                ++ans;
             }
         }
-        return cnt;
+        return ans;
     }
 }

solution/2200-2299/2270.Number of Ways to Split Array/Solution.py

@@ -1,10 +1,9 @@
 class Solution:
     def waysToSplitArray(self, nums: List[int]) -> int:
-        left, right = 0, sum(nums)
-        cnt = 0
+        s = sum(nums)
+        ans = t = 0
         for v in nums[:-1]:
-            left += v
-            right -= v
-            if left >= right:
-                cnt += 1
-        return cnt
+            t += v
+            if t >= s - t:
+                ans += 1
+        return ans