+ problem 2135

Author: fruit-in

Problemset/2135-Count Words Obtained After Adding a Letter/README.md

@@ -0,0 +1,83 @@
+# 2135. Count Words Obtained After Adding a Letter
+You are given two **0-indexed** arrays of strings `startWords` and `targetWords`. Each string consists of **lowercase English letters** only.
+
+For each string in `targetWords`, check if it is possible to choose a string from `startWords` and perform a **conversion operation** on it to be equal to that from `targetWords`.
+
+The **conversion operation** is described in the following two steps:
+
+1. **Append** any lowercase letter that is **not present** in the string to its end.
+    * For example, if the string is `"abc"`, the letters `'d'`, `'e'`, or `'y'` can be added to it, but not `'a'`. If `'d'` is added, the resulting string will be `"abcd"`.
+2. **Rearrange** the letters of the new string in **any** arbitrary order.
+    * For example, `"abcd"` can be rearranged to `"acbd"`, `"bacd"`, `"cbda"`, and so on. Note that it can also be rearranged to `"abcd"` itself.
+
+Return *the **number of strings** in* `targetWords` *that can be obtained by performing the operations on **any** string of* `startWords`.
+
+**Note** that you will only be verifying if the string in `targetWords` can be obtained from a string in `startWords` by performing the operations. The strings in `startWords` **do not** actually change during this process.
+
+#### Example 1:
+<pre>
+<strong>Input:</strong> startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"]
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+- In order to form targetWords[0] = "tack", we use startWords[1] = "act", append 'k' to it, and rearrange "actk" to "tack".
+- There is no string in startWords that can be used to obtain targetWords[1] = "act".
+  Note that "act" does exist in startWords, but we must append one letter to the string before rearranging it.
+- In order to form targetWords[2] = "acti", we use startWords[1] = "act", append 'i' to it, and rearrange "acti" to "acti" itself.
+</pre>
+
+#### Example 2:
+<pre>
+<strong>Input:</strong> startWords = ["ab","a"], targetWords = ["abc","abcd"]
+<strong>Output:</strong> 1
+<strong>Explanation:</strong>
+- In order to form targetWords[0] = "abc", we use startWords[0] = "ab", add 'c' to it, and rearrange it to "abc".
+- There is no string in startWords that can be used to obtain targetWords[1] = "abcd".
+</pre>
+
+#### Constraints:
+* <code>1 <= startWords.length, targetWords.length <= 5 * 10<sup>4</sup></code>
+* `1 <= startWords[i].length, targetWords[j].length <= 26`
+* Each string of `startWords` and `targetWords` consists of lowercase English letters only.
+* No letter occurs more than once in any string of `startWords` or `targetWords`.
+
+## Solutions (Rust)
+
+### 1. Solution
+```Rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_count(start_words: Vec<String>, target_words: Vec<String>) -> i32 {
+        let mut target_count = HashMap::new();
+        let mut ret = 0;
+
+        for target in target_words {
+            let mut count = [0; 26];
+
+            for ch in target.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            *target_count.entry(count).or_insert(0) += 1;
+        }
+
+        for start in start_words {
+            let mut count = [0; 26];
+
+            for ch in start.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            for i in 0..26 {
+                if count[i] == 0 {
+                    let mut tmp = count;
+                    tmp[i] = 1;
+                    ret += target_count.remove(&tmp).unwrap_or(0);
+                }
+            }
+        }
+
+        ret
+    }
+}
+```

Problemset/2135-Count Words Obtained After Adding a Letter/README_CN.md

@@ -0,0 +1,83 @@
+# 2135. 统计追加字母可以获得的单词数
+给你两个下标从 **0** 开始的字符串数组 `startWords` 和 `targetWords` 。每个字符串都仅由 **小写英文字母** 组成。
+
+对于 `targetWords` 中的每个字符串，检查是否能够从 `startWords` 中选出一个字符串，执行一次 **转换操作** ，得到的结果与当前 `targetWords` 字符串相等。
+
+**转换操作** 如下面两步所述：
+
+1. **追加** 任何 **不存在** 于当前字符串的任一小写字母到当前字符串的末尾。
+    * 例如，如果字符串为 `"abc"` ，那么字母 `'d'`、`'e'` 或 `'y'` 都可以加到该字符串末尾，但 `'a'` 就不行。如果追加的是 `'d'` ，那么结果字符串为 `"abcd"` 。
+2. **重排** 新字符串中的字母，可以按 **任意** 顺序重新排布字母。
+    * 例如，`"abcd"` 可以重排为 `"acbd"`、`"bacd"`、`"cbda"`，以此类推。注意，它也可以重排为 `"abcd"` 自身。
+
+找出 `targetWords` 中有多少字符串能够由 `startWords` 中的 **任一** 字符串执行上述转换操作获得。返回 `targetWords` 中这类 **字符串的数目** 。
+
+**注意：**你仅能验证 `targetWords` 中的字符串是否可以由 `startWords` 中的某个字符串经执行操作获得。`startWords`  中的字符串在这一过程中 **不** 发生实际变更。
+
+#### 示例 1:
+<pre>
+<strong>输入:</strong> startWords = ["ant","act","tack"], targetWords = ["tack","act","acti"]
+<strong>输出:</strong> 2
+<strong>解释:</strong>
+- 为了形成 targetWords[0] = "tack" ，可以选用 startWords[1] = "act" ，追加字母 'k' ，并重排 "actk" 为 "tack" 。
+- startWords 中不存在可以用于获得 targetWords[1] = "act" 的字符串。
+  注意 "act" 确实存在于 startWords ，但是 必须 在重排前给这个字符串追加一个字母。
+- 为了形成 targetWords[2] = "acti" ，可以选用 startWords[1] = "act" ，追加字母 'i' ，并重排 "acti" 为 "acti" 自身。
+</pre>
+
+#### 示例 2:
+<pre>
+<strong>输入:</strong> startWords = ["ab","a"], targetWords = ["abc","abcd"]
+<strong>输出:</strong> 1
+<strong>解释:</strong>
+- 为了形成 targetWords[0] = "abc" ，可以选用 startWords[0] = "ab" ，追加字母 'c' ，并重排为 "abc" 。
+- startWords 中不存在可以用于获得 targetWords[1] = "abcd" 的字符串。
+</pre>
+
+#### 提示:
+* <code>1 <= startWords.length, targetWords.length <= 5 * 10<sup>4</sup></code>
+* `1 <= startWords[i].length, targetWords[j].length <= 26`
+* `startWords` 和 `targetWords` 中的每个字符串都仅由小写英文字母组成
+* 在 `startWords` 或 `targetWords` 的任一字符串中，每个字母至多出现一次
+
+## 题解 (Rust)
+
+### 1. 题解
+```Rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_count(start_words: Vec<String>, target_words: Vec<String>) -> i32 {
+        let mut target_count = HashMap::new();
+        let mut ret = 0;
+
+        for target in target_words {
+            let mut count = [0; 26];
+
+            for ch in target.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            *target_count.entry(count).or_insert(0) += 1;
+        }
+
+        for start in start_words {
+            let mut count = [0; 26];
+
+            for ch in start.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            for i in 0..26 {
+                if count[i] == 0 {
+                    let mut tmp = count;
+                    tmp[i] = 1;
+                    ret += target_count.remove(&tmp).unwrap_or(0);
+                }
+            }
+        }
+
+        ret
+    }
+}
+```

Problemset/2135-Count Words Obtained After Adding a Letter/Solution.rs

@@ -0,0 +1,36 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn word_count(start_words: Vec<String>, target_words: Vec<String>) -> i32 {
+        let mut target_count = HashMap::new();
+        let mut ret = 0;
+
+        for target in target_words {
+            let mut count = [0; 26];
+
+            for ch in target.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            *target_count.entry(count).or_insert(0) += 1;
+        }
+
+        for start in start_words {
+            let mut count = [0; 26];
+
+            for ch in start.bytes() {
+                count[(ch - b'a') as usize] += 1;
+            }
+
+            for i in 0..26 {
+                if count[i] == 0 {
+                    let mut tmp = count;
+                    tmp[i] = 1;
+                    ret += target_count.remove(&tmp).unwrap_or(0);
+                }
+            }
+        }
+
+        ret
+    }
+}

README.md

@@ -1116,6 +1116,7 @@
 [2131][2131l]|[Longest Palindrome by Concatenating Two Letter Words][2131]                          |![rs]
 [2133][2133l]|[Check if Every Row and Column Contains All Numbers][2133]                            |![rs]
 [2134][2134l]|[Minimum Swaps to Group All 1's Together II][2134]                                    |![rs]
+[2135][2135l]|[Count Words Obtained After Adding a Letter][2135]                                    |![rs]
 [2138][2138l]|[Divide a String Into Groups of Size k][2138]                                         |![py]
 [2139][2139l]|[Minimum Moves to Reach Target Score][2139]                                           |![rs]
 [2140][2140l]|[Solving Questions With Brainpower][2140]                                             |![rs]
@@ -2448,6 +2449,7 @@
 [2131]:Problemset/2131-Longest%20Palindrome%20by%20Concatenating%20Two%20Letter%20Words/README.md#2131-longest-palindrome-by-concatenating-two-letter-words
 [2133]:Problemset/2133-Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers/README.md#2133-check-if-every-row-and-column-contains-all-numbers
 [2134]:Problemset/2134-Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/README.md#2134-minimum-swaps-to-group-all-1s-together-ii
+[2135]:Problemset/2135-Count%20Words%20Obtained%20After%20Adding%20a%20Letter/README.md#2135-count-words-obtained-after-adding-a-letter
 [2138]:Problemset/2138-Divide%20a%20String%20Into%20Groups%20of%20Size%20k/README.md#2138-divide-a-string-into-groups-of-size-k
 [2139]:Problemset/2139-Minimum%20Moves%20to%20Reach%20Target%20Score/README.md#2139-minimum-moves-to-reach-target-score
 [2140]:Problemset/2140-Solving%20Questions%20With%20Brainpower/README.md#2140-solving-questions-with-brainpower
@@ -3783,6 +3785,7 @@
 [2131l]:https://leetcode.com/problems/longest-palindrome-by-concatenating-two-letter-words/
 [2133l]:https://leetcode.com/problems/check-if-every-row-and-column-contains-all-numbers/
 [2134l]:https://leetcode.com/problems/minimum-swaps-to-group-all-1s-together-ii/
+[2135l]:https://leetcode.com/problems/count-words-obtained-after-adding-a-letter/
 [2138l]:https://leetcode.com/problems/divide-a-string-into-groups-of-size-k/
 [2139l]:https://leetcode.com/problems/minimum-moves-to-reach-target-score/
 [2140l]:https://leetcode.com/problems/solving-questions-with-brainpower/

README_CN.md

@@ -1116,6 +1116,7 @@
 [2131][2131l]|[连接两字母单词得到的最长回文串][2131]                    |![rs]
 [2133][2133l]|[检查是否每一行每一列都包含全部整数][2133]                |![rs]
 [2134][2134l]|[最少交换次数来组合所有的 1 II][2134]                     |![rs]
+[2135][2135l]|[统计追加字母可以获得的单词数][2135]                      |![rs]
 [2138][2138l]|[将字符串拆分为若干长度为 k 的组][2138]                   |![py]
 [2139][2139l]|[得到目标值的最少行动次数][2139]                          |![rs]
 [2140][2140l]|[解决智力问题][2140]                                      |![rs]
@@ -2448,6 +2449,7 @@
 [2131]:Problemset/2131-Longest%20Palindrome%20by%20Concatenating%20Two%20Letter%20Words/README_CN.md#2131-连接两字母单词得到的最长回文串
 [2133]:Problemset/2133-Check%20if%20Every%20Row%20and%20Column%20Contains%20All%20Numbers/README_CN.md#2133-检查是否每一行每一列都包含全部整数
 [2134]:Problemset/2134-Minimum%20Swaps%20to%20Group%20All%201's%20Together%20II/README_CN.md#2134-最少交换次数来组合所有的-1-ii
+[2135]:Problemset/2135-Count%20Words%20Obtained%20After%20Adding%20a%20Letter/README_CN.md#2135-统计追加字母可以获得的单词数
 [2138]:Problemset/2138-Divide%20a%20String%20Into%20Groups%20of%20Size%20k/README_CN.md#2138-将字符串拆分为若干长度为-k-的组
 [2139]:Problemset/2139-Minimum%20Moves%20to%20Reach%20Target%20Score/README_CN.md#2139-得到目标值的最少行动次数
 [2140]:Problemset/2140-Solving%20Questions%20With%20Brainpower/README_CN.md#2140-解决智力问题
@@ -3783,6 +3785,7 @@
 [2131l]:https://leetcode.cn/problems/longest-palindrome-by-concatenating-two-letter-words/
 [2133l]:https://leetcode.cn/problems/check-if-every-row-and-column-contains-all-numbers/
 [2134l]:https://leetcode.cn/problems/minimum-swaps-to-group-all-1s-together-ii/
+[2135l]:https://leetcode.cn/problems/count-words-obtained-after-adding-a-letter/
 [2138l]:https://leetcode.cn/problems/divide-a-string-into-groups-of-size-k/
 [2139l]:https://leetcode.cn/problems/minimum-moves-to-reach-target-score/
 [2140l]:https://leetcode.cn/problems/solving-questions-with-brainpower/