S

Author: trinhminhtriet

solutions/1900-1999/1935.maximum-number-of-words-you-can-type/Solution.cs

@@ -0,0 +1,20 @@
+public class Solution {
+    public int CanBeTypedWords(string text, string brokenLetters) {
+        bool[] s = new bool[26];
+        foreach (char c in brokenLetters) {
+            s[c - 'a'] = true;
+        }
+        int ans = 0;
+        string[] words = text.Split(' ');
+        foreach (string w in words) {
+            foreach (char c in w) {
+                if (s[c - 'a']) {
+                    --ans;
+                    break;
+                }
+            }
+            ++ans;
+        }
+        return ans;
+    }
+}

solutions/3600-3699/3678.smallest-absent-positive-greater-than-average/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int smallestAbsent(vector<int>& nums) {
+        unordered_set<int> s;
+        int sum = 0;
+        for (int x : nums) {
+            s.insert(x);
+            sum += x;
+        }
+        int ans = max(1, sum / (int) nums.size() + 1);
+        while (s.contains(ans)) {
+            ++ans;
+        }
+        return ans;
+    }
+};

solutions/3600-3699/3678.smallest-absent-positive-greater-than-average/Solution.go

@@ -0,0 +1,13 @@
+func smallestAbsent(nums []int) int {
+	s := map[int]bool{}
+	sum := 0
+	for _, x := range nums {
+		s[x] = true
+		sum += x
+	}
+	ans := max(1, sum/len(nums)+1)
+	for s[ans] {
+		ans++
+	}
+	return ans
+}

solutions/3600-3699/3678.smallest-absent-positive-greater-than-average/Solution.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int smallestAbsent(int[] nums) {
+        Set<Integer> s = new HashSet<>();
+        int sum = 0;
+        for (int x : nums) {
+            s.add(x);
+            sum += x;
+        }
+        int ans = Math.max(1, sum / nums.length + 1);
+        while (s.contains(ans)) {
+            ++ans;
+        }
+        return ans;
+    }
+}

solutions/3600-3699/3678.smallest-absent-positive-greater-than-average/Solution.py

@@ -0,0 +1,7 @@
+class Solution:
+    def smallestAbsent(self, nums: List[int]) -> int:
+        s = set(nums)
+        ans = max(1, sum(nums) // len(nums) + 1)
+        while ans in s:
+            ans += 1
+        return ans

solutions/3600-3699/3678.smallest-absent-positive-greater-than-average/Solution.ts

@@ -0,0 +1,9 @@
+function smallestAbsent(nums: number[]): number {
+    const s = new Set<number>(nums);
+    const sum = nums.reduce((a, b) => a + b, 0);
+    let ans = Math.max(1, Math.floor(sum / nums.length) + 1);
+    while (s.has(ans)) {
+        ans++;
+    }
+    return ans;
+}

solutions/3600-3699/3683.earliest-time-to-finish-one-task/README.md

@@ -0,0 +1,131 @@
+---
+comments: true
+difficulty: Easy
+---
+
+<!-- problem:start -->
+
+# [3683. Earliest Time to Finish One Task](https://leetcode.com/problems/earliest-time-to-finish-one-task)
+
+[中文文档](/solution/3600-3699/3683.Earliest%20Time%20to%20Finish%20One%20Task/README.md)
+
+## Description
+
+<!-- description:start -->
+
+<p>You are given a 2D integer array <code>tasks</code> where <code>tasks[i] = [s<sub>i</sub>, t<sub>i</sub>]</code>.</p>
+
+<p>Each <code>[s<sub>i</sub>, t<sub>i</sub>]</code> in <code>tasks</code> represents a task with start time <code>s<sub>i</sub></code> that takes <code>t<sub>i</sub></code> units of time to finish.</p>
+
+<p>Return the earliest time at which at least one task is finished.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">tasks = [[1,6],[2,3]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">5</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>The first task starts at time <code>t = 1</code> and finishes at time <code>1 + 6 = 7</code>. The second task finishes at time <code>2 + 3 = 5</code>. You can finish one task at time 5.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">tasks = [[100,100],[100,100],[100,100]]</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">200</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>All three tasks finish at time <code>100 + 100 = 200</code>.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= tasks.length &lt;= 100</code></li>
+	<li><code>tasks[i] = [s<sub>i</sub>, t<sub>i</sub>]</code></li>
+	<li><code>1 &lt;= s<sub>i</sub>, t<sub>i</sub> &lt;= 100</code></li>
+</ul>
+
+<!-- description:end -->
+
+## Solutions
+
+<!-- solution:start -->
+
+### Solution 1: Single Pass
+
+We iterate through the $\textit{tasks}$ array and, for each task, calculate its completion time $s_i + t_i$. The minimum of all task completion times is the earliest time to finish at least one task.
+
+The time complexity is $O(n)$, where $n$ is the length of the $\textit{tasks}$ array. The space complexity is $O(1)$.
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def earliestTime(self, tasks: List[List[int]]) -> int:
+        return min(s + t for s, t in tasks)
+```
+
+#### Java
+
+```java
+class Solution {
+    public int earliestTime(int[][] tasks) {
+        int ans = 200;
+        for (var task : tasks) {
+            ans = Math.min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int earliestTime(vector<vector<int>>& tasks) {
+        int ans = 200;
+        for (const auto& task : tasks) {
+            ans = min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func earliestTime(tasks [][]int) int {
+	ans := 200
+	for _, task := range tasks {
+		ans = min(ans, task[0]+task[1])
+	}
+	return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function earliestTime(tasks: number[][]): number {
+    return Math.min(...tasks.map(task => task[0] + task[1]));
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- problem:end -->

solutions/3600-3699/3683.earliest-time-to-finish-one-task/Solution.cpp

@@ -0,0 +1,10 @@
+class Solution {
+public:
+    int earliestTime(vector<vector<int>>& tasks) {
+        int ans = 200;
+        for (const auto& task : tasks) {
+            ans = min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+};

solutions/3600-3699/3683.earliest-time-to-finish-one-task/Solution.go

@@ -0,0 +1,7 @@
+func earliestTime(tasks [][]int) int {
+	ans := 200
+	for _, task := range tasks {
+		ans = min(ans, task[0]+task[1])
+	}
+	return ans
+}

solutions/3600-3699/3683.earliest-time-to-finish-one-task/Solution.java

@@ -0,0 +1,9 @@
+class Solution {
+    public int earliestTime(int[][] tasks) {
+        int ans = 200;
+        for (var task : tasks) {
+            ans = Math.min(ans, task[0] + task[1]);
+        }
+        return ans;
+    }
+}