LeetCode每日一题（2）——最常见的单词

1.题目

给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。

题目保证至少有一个词不在禁用列表中，而且答案唯一。

禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。

2.示例

输入:
paragraph = “Bob hit a ball, the hit BALL flew far after it was hit.”
banned = [“hit”]
输出: “ball”
解释: “hit” 出现了3次，但它是一个禁用的单词。 "ball"出现了2次 (同时没有其他单词出现2次)，所以它是段落里出现次数最多的，且不在禁用列表中的单词。

注意，所有这些单词在段落里不区分大小写，标点符号需要忽略（即使是紧挨着单词也忽略， 比如 “ball,”），
"hit"不是最终的答案，虽然它出现次数更多，但它在禁用单词列表中。

提示：

1 <= 段落长度 <= 1000 0 <= 禁用单词个数 <= 100
1 <= 禁用单词长度 <= 10
答案是唯一的, 且都是小写字母
(即使在 paragraph 里是大写的，即使是一些特定的名词，答案都是小写的。)
paragraph只包含字母、空格和下列标点符号!?',;.
不存在没有连字符或者带有连字符的单词。
单词里只包含字母，不会出现省略号或者其他标点符号。

3.思路

将段落分成一个个单词，除去ban掉的单词，统计其他单词出现的数量，返回数量最多的单词即可。思路都差不多，处理方式就更重要。我的反面教材如下

func splitString(r rune) bool {
	return r == '!' || r == '?' || r == '\'' || r == ',' || r == ';'|| r == '.' || r == ' '
}

func splitStringChar(s string) []string {
	a := strings.FieldsFunc(s, splitString)
	return a
}

func mostCommonWord(paragraph string, banned []string) string {
	//将string内的所有大写字母改为小写
	low := strings.ToLower(paragraph)
	//将小写的string按空格分成数组
	all := splitStringChar(low)
	//fmt.Println(all)

	//将禁用列表（切片）存为map的key便于判断
	ban := make(map[string]bool,len(banned))
	for i := 0; i < len(banned); i++{
		ban[banned[i]] = false
	}
	//fmt.Println(ban)

	//用切片保存每个词出现的数量
	count := make(map[string]int,len(all))
	for i := 0 ; i < len(all); i++{
		fmt.Printf("第%d个是%v\n",i,all[i])
		_, ok := count[all[i]]
		if ok{
			fmt.Printf("计数器存在%v\n",all[i])
			//在这里想起来还要判断是否在禁用列表，
			//再次for循环依次与禁用列表比较会增加时间复杂度
			//虽然go没有python的判断是否存在列表中的方法in
			//但是map有类似的能力，即将数组存为map的key
			_, ok := ban[all[i]]
			if ok{
				fmt.Printf("%v被ban\n",all[i])
			}else {
				fmt.Printf("%v数量+1\n", all[i])
				count[all[i]] = count[all[i]]+1
			}
		}else{
			fmt.Printf("第一次碰到%v\n",all[i])
			_, ok := ban[all[i]]
			if ok{
				fmt.Printf("%v被ban\n", all[i])
			}else {
				fmt.Println("没有被ban")
				count[all[i]] = 1
			}
		}
	}
	max := 0
	var most string

	for k, v := range count {
		fmt.Println(k,v)
		if v > max{
			max = v
			most = k
		}
	}
	return most
}

func main() {
	a := "Bob. hIt, baLl"
	var b = []string{"bob", "hit"}
	fmt.Printf("数量最多且没有被ban的单词是%v",mostCommonWord(a, b))
}

另外
通过类似如下的操作可以自定义很多处理方式

func splitString(r rune) bool {
	return r == '!' || r == '?' || r == '\'' || r == ',' || r == ';'|| r == '.' || r == ' '
}

func splitStringChar(s string) []string {
	a := strings.FieldsFunc(s, splitString)
	return a
}

不过通过了以后执行用时和内存消耗都很拉，一看官方题解发现竟然还有unicode.IsLetter这种操作。

4.代码（官方）

func mostCommonWord(paragraph string, banned []string) string {
    ban := map[string]bool{}
    for _, s := range banned {
        ban[s] = true
    }
    freq := map[string]int{}
    maxFreq := 0
    var word []byte
    for i, n := 0, len(paragraph); i <= n; i++ {
        if i < n && unicode.IsLetter(rune(paragraph[i])) {
            word = append(word, byte(unicode.ToLower(rune(paragraph[i]))))
        } else if word != nil {
            s := string(word)
            if !ban[s] {
                freq[s]++
                maxFreq = max(maxFreq, freq[s])
            }
            word = nil
        }
    }
    for s, f := range freq {
        if f == maxFreq {
            return s
        }
    }
    return ""
}

func max(a, b int) int {
    if b > a {
        return b
    }
    return a
}

5.最后

除了开挂似的unicode.IsLetter，可以发现在判断切片或数组中是否含有某元素时，官方同样采取了存为map的key的方法。例如官方的!ban[s]意思就是ban这个map里有没有叫做s的key，我的代码_, ok := count[all[i]]中的ok为ture代表count这个map里有叫做all[i]的key。