feat: add solutions to lc problem: No.1684

No.1684.Count the Number of Consistent Strings

Author: YangFong

solution/1600-1699/1684.Count the Number of Consistent Strings/README.md

@@ -225,6 +225,137 @@ func countConsistentStrings(allowed string, words []string) (ans int) {
 }
 ```
 
+### **C**
+
+```c
+int countConsistentStrings(char *allowed, char **words, int wordsSize) {
+    int n = strlen(allowed);
+    int make[26] = {0};
+    for (int i = 0; i < n; i++) {
+        make[allowed[i] - 'a'] = 1;
+    }
+    int ans = wordsSize;
+    for (int i = 0; i < wordsSize; i++) {
+        char *word = words[i];
+        for (int j = 0; j < strlen(word); j++) {
+            if (!make[word[j] - 'a']) {
+                ans--;
+                break;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```c
+int helper(char *s) {
+    int res = 0;
+    int n = strlen(s);
+    for (int i = 0; i < n; i++) {
+        res |= 1 << (s[i] - 'a');
+    }
+    return res;
+}
+
+int countConsistentStrings(char *allowed, char **words, int wordsSize) {
+    int mask = helper(allowed);
+    int ans = 0;
+    for (int i = 0; i < wordsSize; i++) {
+        if ((mask | helper(words[i])) == mask) {
+            ans++;
+        }
+    }
+    return ans;
+}
+```
+
+### **TypeScript**
+
+```ts
+function countConsistentStrings(allowed: string, words: string[]): number {
+    const set = new Set([...allowed]);
+    const n = words.length;
+    let ans = n;
+    for (const word of words) {
+        for (const c of word) {
+            if (!set.has(c)) {
+                ans--;
+                break;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function countConsistentStrings(allowed: string, words: string[]): number {
+    const helper = (s: string) => {
+        let res = 0;
+        for (const c of s) {
+            res |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
+        }
+        return res;
+    };
+    const mask = helper(allowed);
+    let ans = 0;
+    for (const word of words) {
+        if ((mask | helper(word)) === mask) {
+            ans++;
+        }
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let n = words.len();
+        let mut make = [false; 26];
+        for c in allowed.as_bytes() {
+            make[(c - b'a') as usize] = true;
+        }
+        let mut ans = n as i32;
+        for word in words.iter() {
+            for c in word.as_bytes().iter() {
+                if !make[(c - b'a') as usize] {
+                    ans -= 1;
+                    break;
+                }
+            }
+        }
+        ans
+    }
+}
+```
+
+```rust
+impl Solution {
+    fn helper(s: &String) -> i32 {
+        let mut res = 0;
+        for c in s.as_bytes().iter() {
+            res |= 1 << (c - b'a') as i32;
+        }
+        res
+    }
+
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let mask = Self::helper(&allowed);
+        let mut ans = 0;
+        for word in words.iter() {
+            if (mask | Self::helper(word)) == mask {
+                ans += 1;
+            }
+        }
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1684.Count the Number of Consistent Strings/README_EN.md

@@ -199,6 +199,137 @@ func countConsistentStrings(allowed string, words []string) (ans int) {
 }
 ```
 
+### **C**
+
+```c
+int countConsistentStrings(char *allowed, char **words, int wordsSize) {
+    int n = strlen(allowed);
+    int make[26] = {0};
+    for (int i = 0; i < n; i++) {
+        make[allowed[i] - 'a'] = 1;
+    }
+    int ans = wordsSize;
+    for (int i = 0; i < wordsSize; i++) {
+        char *word = words[i];
+        for (int j = 0; j < strlen(word); j++) {
+            if (!make[word[j] - 'a']) {
+                ans--;
+                break;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```c
+int helper(char *s) {
+    int res = 0;
+    int n = strlen(s);
+    for (int i = 0; i < n; i++) {
+        res |= 1 << (s[i] - 'a');
+    }
+    return res;
+}
+
+int countConsistentStrings(char *allowed, char **words, int wordsSize) {
+    int mask = helper(allowed);
+    int ans = 0;
+    for (int i = 0; i < wordsSize; i++) {
+        if ((mask | helper(words[i])) == mask) {
+            ans++;
+        }
+    }
+    return ans;
+}
+```
+
+### **TypeScript**
+
+```ts
+function countConsistentStrings(allowed: string, words: string[]): number {
+    const set = new Set([...allowed]);
+    const n = words.length;
+    let ans = n;
+    for (const word of words) {
+        for (const c of word) {
+            if (!set.has(c)) {
+                ans--;
+                break;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function countConsistentStrings(allowed: string, words: string[]): number {
+    const helper = (s: string) => {
+        let res = 0;
+        for (const c of s) {
+            res |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
+        }
+        return res;
+    };
+    const mask = helper(allowed);
+    let ans = 0;
+    for (const word of words) {
+        if ((mask | helper(word)) === mask) {
+            ans++;
+        }
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let n = words.len();
+        let mut make = [false; 26];
+        for c in allowed.as_bytes() {
+            make[(c - b'a') as usize] = true;
+        }
+        let mut ans = n as i32;
+        for word in words.iter() {
+            for c in word.as_bytes().iter() {
+                if !make[(c - b'a') as usize] {
+                    ans -= 1;
+                    break;
+                }
+            }
+        }
+        ans
+    }
+}
+```
+
+```rust
+impl Solution {
+    fn helper(s: &String) -> i32 {
+        let mut res = 0;
+        for c in s.as_bytes().iter() {
+            res |= 1 << (c - b'a') as i32;
+        }
+        res
+    }
+
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let mask = Self::helper(&allowed);
+        let mut ans = 0;
+        for word in words.iter() {
+            if (mask | Self::helper(word)) == mask {
+                ans += 1;
+            }
+        }
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1684.Count the Number of Consistent Strings/Solution.c

@@ -0,0 +1,19 @@
+int helper(char *s) {
+    int res = 0;
+    int n = strlen(s);
+    for (int i = 0; i < n; i++) {
+        res |= 1 << (s[i] - 'a');
+    }
+    return res;
+}
+
+int countConsistentStrings(char *allowed, char **words, int wordsSize) {
+    int mask = helper(allowed);
+    int ans = 0;
+    for (int i = 0; i < wordsSize; i++) {
+        if ((mask | helper(words[i])) == mask) {
+            ans++;
+        }
+    }
+    return ans;
+}

solution/1600-1699/1684.Count the Number of Consistent Strings/Solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    fn helper(s: &String) -> i32 {
+        let mut res = 0;
+        for c in s.as_bytes().iter() {
+            res |= 1 << (c - b'a') as i32;
+        }
+        res
+    }
+
+    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
+        let mask = Self::helper(&allowed);
+        let mut ans = 0;
+        for word in words.iter() {
+            if (mask | Self::helper(word)) == mask {
+                ans += 1;
+            }
+        }
+        ans
+    }
+}

solution/1600-1699/1684.Count the Number of Consistent Strings/Solution.ts

@@ -0,0 +1,17 @@
+function countConsistentStrings(allowed: string, words: string[]): number {
+    const helper = (s: string) => {
+        let res = 0;
+        for (const c of s) {
+            res |= 1 << (c.charCodeAt(0) - 'a'.charCodeAt(0));
+        }
+        return res;
+    };
+    const mask = helper(allowed);
+    let ans = 0;
+    for (const word of words) {
+        if ((mask | helper(word)) === mask) {
+            ans++;
+        }
+    }
+    return ans;
+}