1684-CountTheNumberOfConsistentStrings.go

package main

// 1684. Count the Number of Consistent Strings
// You are given a string allowed consisting of distinct characters and an array of strings words. 
// A string is consistent if all characters in the string appear in the string allowed.

// Return the number of consistent strings in the array words.

// Example 1:
// Input: allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
// Output: 2
// Explanation: Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.

// Example 2:
// Input: allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
// Output: 7
// Explanation: All strings are consistent.

// Example 3:
// Input: allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
// Output: 4
// Explanation: Strings "cc", "acd", "ac", and "d" are consistent.

// Constraints:
//     1 <= words.length <= 10^4
//     1 <= allowed.length <= 26
//     1 <= words[i].length <= 10
//     The characters in allowed are distinct.
//     words[i] and allowed contain only lowercase English letters.

import "fmt"

func countConsistentStrings(allowed string, words []string) int {
    res, mp := 0, make(map[byte]bool)
    for i := range allowed {
        mp[allowed[i]] = true
    }
    for _, word := range words {
        flag := true
        for i := range word {
            if !mp[word[i]] { // 出了不在 allowed 中的字符
                flag = false
                break
            }
        }
        if flag { res++ }
    }
    return res
}

func countConsistentStrings1(allowed string, words []string) int {
    res, mp := 0, [26]bool{}
    for i := range allowed {
        mp[int(allowed[i] - 'a')] = true
    }
    for _, word := range words {
        flag := true
        for i := range word {
            if !mp[int(word[i] - 'a')] { // 出了不在 allowed 中的字符
                flag = false
                break
            }
        }
        if flag { res++ }
    }
    return res
}

func main() {
    // Example 1:
    // Input: allowed = "ab", words = ["ad","bd","aaab","baa","badab"]
    // Output: 2
    // Explanation: Strings "aaab" and "baa" are consistent since they only contain characters 'a' and 'b'.
    fmt.Println(countConsistentStrings("ab",[]string{"ad","bd","aaab","baa","badab"})) // 2
    // Example 2:
    // Input: allowed = "abc", words = ["a","b","c","ab","ac","bc","abc"]
    // Output: 7
    // Explanation: All strings are consistent.
    fmt.Println(countConsistentStrings("abc",[]string{"a","b","c","ab","ac","bc","abc"})) // 7
    // Example 3:
    // Input: allowed = "cad", words = ["cc","acd","b","ba","bac","bad","ac","d"]
    // Output: 4
    // Explanation: Strings "cc", "acd", "ac", and "d" are consistent.
    fmt.Println(countConsistentStrings("cad",[]string{"cc","acd","b","ba","bac","bad","ac","d"})) // 4

    fmt.Println(countConsistentStrings1("ab",[]string{"ad","bd","aaab","baa","badab"})) // 2
    fmt.Println(countConsistentStrings1("abc",[]string{"a","b","c","ab","ac","bc","abc"})) // 7
    fmt.Println(countConsistentStrings1("cad",[]string{"cc","acd","b","ba","bac","bad","ac","d"})) // 4
}