LC 1684. Count the Number of Consistent Strings (Rust)

Author: raul-sauco

.pre-commit-config.yaml

@@ -1,18 +1,20 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.2.0
+    rev: v4.6.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
       - id: check-added-large-files
 
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v2.7.1
+    rev: v3.1.0
     hooks:
       - id: prettier
+        additional_dependencies:
+          - [email protected] # SEE: https://github.com/pre-commit/pre-commit/issues/3133
 
   - repo: https://github.com/psf/black
-    rev: 23.3.0
+    rev: 24.8.0
     hooks:
       - id: black
         args:
@@ -23,6 +25,6 @@ repos:
           #    hooks:
           #    -   id: markdownlint
   - repo: https://github.com/crate-ci/typos
-    rev: v1.14.10
+    rev: v1.24.5
     hooks:
       - id: typos

README.md

@@ -575,6 +575,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [1669. Merge In Between Linked Lists][lc1669]                                                 | 🟠 Medium  | [![python](res/py.png)][lc1669py]                                                                     |
 | [1675. Minimize Deviation in Array][lc1675]                                                   | 🔴 Hard    | [![python](res/py.png)][lc1675py] [![rust](res/rs.png)][lc1675rs]                                     |
 | [1680. Concatenation of Consecutive Binary Numbers][lc1680]                                   | 🟠 Medium  | [![python](res/py.png)][lc1680py]                                                                     |
+| [1684. Count the Number of Consistent Strings][lc1684]                                        | 🟢 Easy    | [![rust](res/rs.png)][lc1684rs]                                                                       |
 | [1685. Sum of Absolute Differences in a Sorted Array][lc1685]                                 | 🟠 Medium  | [![rust](res/rs.png)][lc1685rs]                                                                       |
 | [1689. Partitioning Into Minimum Number Of Deci-Binary Numbers][lc1689]                       | 🟠 Medium  | [![python](res/py.png)][lc1689py]                                                                     |
 | [1695. Maximum Erasure Value][lc1695]                                                         | 🟠 Medium  | [![python](res/py.png)][lc1695py]                                                                     |
@@ -2032,6 +2033,8 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc1675rs]: leetcode/minimize-deviation-in-array.rs
 [lc1680]: https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/
 [lc1680py]: leetcode/concatenation-of-consecutive-binary-numbers.py
+[lc1684]: https://leetcode.com/problems/count-the-number-of-consistent-strings/
+[lc1684rs]: leetcode/count-the-number-of-consistent-strings.rs
 [lc1685]: https://leetcode.com/problems/sum-of-absolute-differences-in-a-sorted-array/
 [lc1685rs]: leetcode/sum-of-absolute-differences-in-a-sorted-array.rs
 [lc1689]: https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/

_typos.toml

@@ -1,6 +1,11 @@
 [default]
 extend-ignore-identifiers-re = []
 
+extend-ignore-re = [
+    "(?Rm)^.*(#|//)\\s*typos:ignore$",
+    "(?s)(#|//)\\s*typos:off.*?\\n\\s*(#|//)\\s*typos:on",
+]
+
 [default.extend-identifiers]
 
 [default.extend-words]

leetcode/count-the-number-of-consistent-strings.rs

@@ -0,0 +1,80 @@
+// 1684. Count the Number of Consistent Strings
+// 🟢 Easy
+//
+// https://leetcode.com/problems/count-the-number-of-consistent-strings/
+//
+// Tags: Array - Hash Table - String - Bit Manipulation - Counting
+
+use std::collections::HashSet;
+
+struct Solution;
+impl Solution {
+    /// Use a way to check in O(1) whether a character is allowed, I used a hash set but we could
+    /// also have used a binary array or the bits of a value with >26 bits, for example an i32.
+    ///
+    /// Time complexity: O(n) - Where n is the number of characters in all the words combined, we
+    /// iterate over all characters checking that they are allowed.
+    /// Space complexity: O(1) - The hashset can grow to a max of size 26.
+    ///
+    /// Runtime 16 ms Beats 48%
+    /// Memory 2.62 MB Beats 55%
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let allowed: HashSet<char> = allowed.chars().collect();
+        let mut res = 0;
+        let mut good;
+        for word in words {
+            good = true;
+            for c in word.chars() {
+                if !allowed.contains(&c) {
+                    good = false;
+                    break;
+                }
+            }
+            if good {
+                res += 1;
+            }
+        }
+        res
+    }
+}
+
+// Tests.
+fn main() {
+    let tests = [
+        ("ab", vec!["ad", "bd", "aaab", "baa", "badab"], 2),
+        ("abc", vec!["a", "b", "c", "ab", "ac", "bc", "abc"], 7),
+        (
+            "cad",
+            vec!["cc", "acd", "b", "ba", "bac", "bad", "ac", "d"], // typos:ignore
+            4,
+        ),
+    ];
+    println!("\n\x1b[92m» Running {} tests...\x1b[0m", tests.len());
+    let mut success = 0;
+    for (i, t) in tests.iter().enumerate() {
+        let res = Solution::count_consistent_strings(
+            t.0.to_string(),
+            t.1.iter().map(|s| s.to_string()).collect::<_>(),
+        );
+        if res == t.2 {
+            success += 1;
+            println!("\x1b[92m✔\x1b[95m Test {} passed!\x1b[0m", i);
+        } else {
+            println!(
+                "\x1b[31mx\x1b[95m Test {} failed expected: {:?} but got {}!!\x1b[0m",
+                i, t.2, res
+            );
+        }
+    }
+    println!();
+    if success == tests.len() {
+        println!("\x1b[30;42m✔ All tests passed!\x1b[0m")
+    } else if success == 0 {
+        println!("\x1b[31mx \x1b[41;37mAll tests failed!\x1b[0m")
+    } else {
+        println!(
+            "\x1b[31mx\x1b[95m {} tests failed!\x1b[0m",
+            tests.len() - success
+        )
+    }
+}