191. 位1的个数 Nnumber of 1-bits

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在 示例 3 中，输入表示有符号整数 -3。

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。

示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

提示：

输入必须是长度为 32 的 二进制串 。

进阶：

如果多次调用这个函数，你将如何优化你的算法？

代码：

package main

import (
	"fmt"
	"math/bits"
)

func hammingWeight1(num int) int {
	sum := 0
	for i := 0; i < 32; i++ {
		if (num>>i)&1 == 1 {
			sum++
		}
	}
	return sum
}

func hammingWeight2(num int) int {
	sum := 0
	for num != 0 {
		num &= num - 1
		sum++
	}
	return sum
}

func hammingWeight3(num int) int {
	return bits.OnesCount32(uint32(num))
}

func main() {
	n := 0b00000000000000000000000000001011
	a := hammingWeight1(n)
	b := hammingWeight2(n)
	c := hammingWeight3(n)
	fmt.Println(a, b, c)

	n = 0b00000000000000000000000010000000
	a = hammingWeight1(n)
	b = hammingWeight2(n)
	c = hammingWeight3(n)
	fmt.Println(a, b, c)

	n = 0b11111111111111111111111111111101
	a = hammingWeight1(n)
	b = hammingWeight2(n)
	c = hammingWeight3(n)
	fmt.Println(a, b, c)
}

输出：

3 3 3
1 1 1
31 31 31

192. 统计词频 Word Frequency

写一个 bash 脚本以统计一个文本文件 words.txt 中每个单词出现的频率。

为了简单起见，你可以假设：

words.txt只包括小写字母和 ' ' 。
每个单词只由小写字母组成。
单词间由一个或多个空格字符分隔。

示例:

假设 words.txt 内容如下：

the day is sunny the the
the sunny is is

你的脚本应当输出（以词频降序排列）：

the 4
is 3
sunny 2
day 1

说明:

不要担心词频相同的单词的排序问题，每个单词出现的频率都是唯一的。
你可以使用一行 Unix pipes 实现吗？

代码：

package main

import (
    "bufio"
    "fmt"
    "os"
    "sort"
    "strings"
)

func main() {
    words := make(map[string]int)

    file, err := os.Open("words.txt")
    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    scanner.Split(bufio.ScanWords)

    for scanner.Scan() {
        word := scanner.Text()
        words[word]++
    }

    if err := scanner.Err(); err != nil {
        fmt.Println(err)
    }

    type kv struct {
        Key   string
        Value int
    }

    var ss []kv
    for k, v := range words {
        ss = append(ss, kv{k, v})
    }

    sort.Slice(ss, func(i, j int) bool {
        return ss[i].Value > ss[j].Value
    })

    for _, kv := range ss {
        fmt.Printf("%s %d\n", kv.Key, kv.Value)
    }
}

调用pipes命令：

package main

import (
    "fmt"
    "os/exec"
    "strings"
)

func main() {
    cmd := exec.Command("bash", "-c", "cat words.txt | awk '{for(i=1; i<=NF; i++) count[$i]++} END {for (w in count) print w, count[w]}'")
    out, err := cmd.Output()
    if err != nil {
        fmt.Println(err)
    }
    lines := strings.Split(string(out), "\n")
    for _, line := range lines {
        if line != "" {
            words := strings.Split(line, " ")
            fmt.Printf("%s %s\n", words[1], words[0])
        }
    }
}