class Solution {
    public int countConsistentStrings(String allowed, String[] words) {
        boolean[] hash = new boolean[26];
        for (var a : allowed.toCharArray())
            hash[a - 'a'] = true;
        int res = 0;
        stop : for (var word : words) {
            for (var w : word.toCharArray()) {
                if (!hash[w - 'a'])
                    continue stop;
            }
            res++;
        }
        return res;
    }
}

class Solution {
public:
    int countConsistentStrings(string allowed, vector<string>& words) {
        int hash[26] = {0};
        for (auto a : allowed)
            hash[a - 'a'] = true;
        int res = 0;
        for (auto& word : words) {
            bool ok = true;
            for (auto w : word) {
                if (!hash[w - 'a']) {
                    ok = false;
                    continue;
                }
            }
            if (ok)
                res++;
        }
        return res;
    }
};

impl Solution {
    pub fn count_consistent_strings(allowed: String, words: Vec<String>) -> i32 {
        let mut hash = vec![false; 26];
        for a in allowed.as_bytes().iter() {
            hash[(a - b'a') as usize] = true;
        }
        let mut res = 0;
        for word in words {
            let mut ok = true;
            for w in word.as_bytes().iter() {
                if !hash[(w - b'a') as usize] {
                    ok = false;
                    continue;
                }
            }
            if ok {
                res += 1;
            }
        }
        res
    }
}