feat: add solutions to lc problems: No.2894~2897

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/README.md

@@ -64,34 +64,82 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：模拟**
+
+我们遍历区间 $[1, n]$ 中的每一个数，如果它能被 $m$ 整除，那么答案就减去这个数，否则答案就加上这个数。
+
+遍历结束后，返回答案即可。
+
+时间复杂度 $O(n)$，其中 $n$ 是题目给定的整数。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def differenceOfSums(self, n: int, m: int) -> int:
+        return sum(i if i % m else -i for i in range(1, n + 1))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m == 0 ? -i : i;
+        }
+        return ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m ? i : -i;
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func differenceOfSums(n int, m int) (ans int) {
+	for i := 1; i <= n; i++ {
+		if i%m == 0 {
+			ans -= i
+		} else {
+			ans += i
+		}
+	}
+	return
+}
+```
+
+### **TypeScript**
 
+```ts
+function differenceOfSums(n: number, m: number): number {
+    let ans = 0;
+    for (let i = 1; i <= n; ++i) {
+        ans += i % m ? i : -i;
+    }
+    return ans;
+}
 ```
 
 ### **...**

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/README_EN.md

@@ -58,30 +58,78 @@ We return 0 - 15 = -15 as the answer.
 
 ## Solutions
 
+**Solution 1: Simulation**
+
+We traverse every number in the range $[1, n]$. If it is divisible by $m$, we subtract it from the answer. Otherwise, we add it to the answer.
+
+After the traversal, we return the answer.
+
+The time complexity is $O(n)$, where $n$ is the given integer. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def differenceOfSums(self, n: int, m: int) -> int:
+        return sum(i if i % m else -i for i in range(1, n + 1))
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m == 0 ? -i : i;
+        }
+        return ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m ? i : -i;
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func differenceOfSums(n int, m int) (ans int) {
+	for i := 1; i <= n; i++ {
+		if i%m == 0 {
+			ans -= i
+		} else {
+			ans += i
+		}
+	}
+	return
+}
+```
+
+### **TypeScript**
 
+```ts
+function differenceOfSums(n: number, m: number): number {
+    let ans = 0;
+    for (let i = 1; i <= n; ++i) {
+        ans += i % m ? i : -i;
+    }
+    return ans;
+}
 ```
 
 ### **...**

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/Solution.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m ? i : -i;
+        }
+        return ans;
+    }
+};

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/Solution.go

@@ -0,0 +1,10 @@
+func differenceOfSums(n int, m int) (ans int) {
+	for i := 1; i <= n; i++ {
+		if i%m == 0 {
+			ans -= i
+		} else {
+			ans += i
+		}
+	}
+	return
+}

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/Solution.java

@@ -0,0 +1,9 @@
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int ans = 0;
+        for (int i = 1; i <= n; ++i) {
+            ans += i % m == 0 ? -i : i;
+        }
+        return ans;
+    }
+}

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def differenceOfSums(self, n: int, m: int) -> int:
+        return sum(i if i % m else -i for i in range(1, n + 1))

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/Solution.ts

@@ -0,0 +1,7 @@
+function differenceOfSums(n: number, m: number): number {
+    let ans = 0;
+    for (let i = 1; i <= n; ++i) {
+        ans += i % m ? i : -i;
+    }
+    return ans;
+}

solution/2800-2899/2895.Minimum Processing Time/README.md

@@ -53,34 +53,105 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：贪心 + 排序**
+
+要使得处理完所有任务的时间最小，那么越早处于空闲状态的处理器应该处理耗时最长的 $4$ 个任务。
+
+因此，我们对处理器的空闲时间和任务的耗时分别进行排序，然后依次将耗时最长的 $4$ 个任务分配给空闲时间最早的处理器，计算最大的结束时间即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为任务的数量。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minProcessingTime(self, processorTime: List[int], tasks: List[int]) -> int:
+        processorTime.sort()
+        tasks.sort()
+        ans = 0
+        i = len(tasks) - 1
+        for t in processorTime:
+            ans = max(ans, t + tasks[i])
+            i -= 4
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int minProcessingTime(List<Integer> processorTime, List<Integer> tasks) {
+        processorTime.sort((a, b) -> a - b);
+        tasks.sort((a, b) -> a - b);
+        int ans = 0, i = tasks.size() - 1;
+        for (int t : processorTime) {
+            ans = Math.max(ans, t + tasks.get(i));
+            i -= 4;
+        }
+        return ans;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int minProcessingTime(vector<int>& processorTime, vector<int>& tasks) {
+        sort(processorTime.begin(), processorTime.end());
+        sort(tasks.begin(), tasks.end());
+        int ans = 0, i = tasks.size() - 1;
+        for (int t : processorTime) {
+            ans = max(ans, t + tasks[i]);
+            i -= 4;
+        }
+        return ans;
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func minProcessingTime(processorTime []int, tasks []int) (ans int) {
+	sort.Ints(processorTime)
+	sort.Ints(tasks)
+	i := len(tasks) - 1
+	for _, t := range processorTime {
+		ans = max(ans, t+tasks[i])
+		i -= 4
+	}
+	return
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
 
+### **TypeScript**
+
+```ts
+function minProcessingTime(processorTime: number[], tasks: number[]): number {
+    processorTime.sort((a, b) => a - b);
+    tasks.sort((a, b) => a - b);
+    let [ans, i] = [0, tasks.length - 1];
+    for (const t of processorTime) {
+        ans = Math.max(ans, t + tasks[i]);
+        i -= 4;
+    }
+    return ans;
+}
 ```
 
 ### **...**