thảo luận Leetcode mỗi ngày

impl Solution {
    fn set_bit_count(mut num: i32) -> i32 {
        let mut c = 0;
        while num != 0 {
            c += 1;
            num &= num - 1;
        }
        c
    }
    pub fn min_bit_flips(start: i32, goal: i32) -> i32 {
        Self::set_bit_count(start ^ goal)
    }
}

var countConsistentStrings = function(allowed, words) {
    const isConsistent = (word, set) => {
        for (const c of word) {
            if (!set.has(c)) {
                return false;
            }
        }
        return true;
    }

    const set = new Set(allowed);
    return words.filter(word => isConsistent(word, set)).length;
};

class Solution {
    public int countConsistentStrings(String allowed, String[] words) {
        int[] counts = new int[26];

        for (int i = 0; i < allowed.length(); i++) {
            char ch = allowed.charAt(i);
            counts[ch - 'a'] = 1;
        }

        int res = 0;
        for (String word : words) {
            int i;
            for (i = 0; i < word.length(); i++) {
                char ch = word.charAt(i);
                if (counts[ch - 'a'] == 0) {
                    break;
                }
            }
            res += i == word.length() ? 1 : 0;
        }

        return res;
    }
}

class Solution {
    public int countConsistentStrings(String allowed, String[] words) {
        int ans = 0;
        int[] freqAllowed = new int[26];
        for (char c : allowed.toCharArray()) {
            freqAllowed[c - 'a']++;
        }
        for (String word : words) {
            int[] freq = new int[26];
            for (char c : word.toCharArray()) {
                freq[c - 'a']++;
            }
            ans++;
            for (int i = 0; i < 26; i++) {
                if (freqAllowed[i] == 0 && freq[i] != 0) {
                    ans--;
                    break;
                }
            }
        }
        return ans;
    }
}

class Solution {
public:
    int countConsistentStrings(string allowed, vector<string>& words) {
        vector<int> count(26, 0);

        for (int i = 0; i < allowed.length(); i++) {
            count[allowed[i] - 'a']++;
        }

        int ans = 0;

        for (int i = 0; i < words.size(); i++) {
            int isConsisted = true;
            for (int j = 0; j < words[i].length(); j++) {
                if (count[words[i][j] - 'a'] == 0) {
                    isConsisted = false;
                    break;
                }
            }
            if (isConsisted) ans++;
        }

        return ans;
    }
};

class Solution:
    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        return sum(all(c in set(allowed) for c in word) for word in words)

class Solution:
    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        allowedSet = set(allowed)
        def isAllowed(s):
            for c in s:
                if not c in allowedSet:
                    return False
            return True
        
        result = 0
        for word in words:
            if isAllowed(word):
                result += 1
        return result

function countConsistentStrings(allowed: string, words: string[]): number {
    const arr = new Array(26).fill(0);
    for (const c of allowed) arr[c.charCodeAt(0) - 'a'.charCodeAt(0)]++
    let res = 0;
    for (const w of words) {
        let check = true;
        for (const c of w) {
            if (!arr[c.charCodeAt(0) - 'a'.charCodeAt(0)]) {
                check = false;
                break;
            }
        }
        res += check ? 1 : 0;
    }
    return res;
};

class Solution {
    public int countConsistentStrings(String allowed, String[] words) {
        int[] map = new int[135];
        int count = 0;

        for(int i = 0; i < allowed.length(); i++) {
            map[allowed.charAt(i)]++;
        }

        for1: for(String s : words) {
            for(int i = 0; i < s.length(); i++) {
                if (map[s.charAt(i)] == 0) {
                    continue for1;
                }
            }

           count++;
        }

        return count;
    }
}