[日常] Go语言*--包和文件-包初始化习题

1.解决包级变量的依赖顺序，然后按照包级变量声明出现的顺序依次初始化

2.包中含有多个.go源文件，它们将按照发给编译器的顺序进行初始化

3.init初始化函数,在每个文件中的init初始化函数，在程序开始执行时按照它们声明的顺序被自动调用

4.每个包在解决依赖的前提下，以导入声明的顺序初始化，每个包只会被初始化一次,在main函数执行之前，所有依赖的包都已经完成初始化工作了

5.一个数字中含二进制1bit的个数算法,统计出一个int型数值中比特值为1的比特个数

&是二进制“与”运算，参加运算的两个数的二进制按位进行运算，运算的规律是：

0 & 0=0

0 & 1=0

1 & 0=0

1 & 1=1

练习 2.3： 重写PopCount函数，用一个循环代替单一的表达式。比较两个版本的性能。（11.4节将展示如何系统地比较两个不同实现的性能。）

练习 2.4： 用移位算法重写PopCount函数，每次测试最右边的1bit，然后统计总数。比较和查表算法的性能差异。

练习 2.5： 表达式x&(x-1)用于将x的最低的一个非零的bit位清零。使用这个算法重写PopCount函数，然后比较性能。

package main
import(
        "fmt"
)

var pc [256]byte

func init() {
    for i := range pc {
        pc[i] = pc[i/2] + byte(i&1)
    }   
}

func main(){
        a := PopCount1(80)
        fmt.Println(a)
        n := PopCountFor(80)
        fmt.Println(n)
}
//练习 2.4： 用移位算法重写PopCount函数，每次测试最右边的1bit，然后统计总数。比较和查表算法的性能差异。
//移位算法
func PopCount1(x uint64) int{
        num := 0
        for i:=0;x!=0;x=x>>1{
                if x&1 == 1{
                        i++ 
                }   
                num=i
        }   
        return num 
}
//练习 2.5： 表达式x&(x-1)用于将x的最低的一个非零的bit位清零。使用这个算法重写PopCount函数，然后比较性能。
//x & (x-1)算法
func PopCount2(x uint64) int{
        num := 0
        for x!=0{
                x = x&(x-1)
                num++
        }   
        return num 
}
//查表法
func PopCount(x uint64) int {
    return int(pc[byte(x>>(0*8))] +
        pc[byte(x>>(1*8))] +
        pc[byte(x>>(2*8))] +
        pc[byte(x>>(3*8))] +
        pc[byte(x>>(4*8))] +
        pc[byte(x>>(5*8))] +
        pc[byte(x>>(6*8))] +
        pc[byte(x>>(7*8))])
}
//练习 2.3： 重写PopCount函数，用一个循环代替单一的表达式。比较两个版本的性能。（11.4节将展示如何系统地比较两个不同实现的性能。）
//查表法,使用循环
func PopCountFor(x uint64) int {
        var num byte
        var i uint64
        for i =0;i<8;i++{
                num+=pc[byte(x>>(i*uint64(8)))]
        }
        return int(num)
}