13.2 Go exercises answer

13.2 Go exercises answer

Exercises:

Creates a main thread goroutine mutual transmission order information and the print number of times

package temp

import "fmt"

//创建一个goroutine与主线程按顺序相互发送信息若干次 且打印
var c chan string //声明一个string管道
func Pingpong() {
    i := 0
    for {
        fmt.Println(<-c) //打印管道中取出的数据
        c <- fmt.Sprintf("From pingpong: say hi ,%d", i)
        i++
    }
}
func main() {
    c = make(chan string) //初始化管道内存
    //协程执行函数
    go Pingpong()
    //主函数循环打印十次
    for i := 0; i < 10; i++ {
        c <- fmt.Sprintf("From main: say hi,%d", i)
        fmt.Println(<-c)
    }
}

slice after the automatic expansion, the memory address changes

package main

import (
    "fmt"
)

/*
//有关slice的坑,slice在自动扩容后,内存地址已经变了
func Pingpong(s []int) {
    s = append(s, 3)
}

func main() {
    s := make([]int, 0)
    fmt.Println(s)
    Pingpong(s)
    fmt.Println(s)
}
*/

//提供返回值,将append这个心的切片返回
func Pingpong(s []int) []int {
    s = append(s, 3)
    return s
}

func main() {
    s := make([]int, 0) //初始容量是0,append后切片地址变了
    fmt.Printf("%p %v\n", s, s)
    s = Pingpong(s)
    fmt.Printf("%p %v\n", s, s)
}

Goroutine the pit closure

package main

import (
    "fmt"
)

func main() {
    s := []string{"a", "b", "c"}
    for _, v := range s {
        //此时func()是个闭包函数,变量v是c
        //可以接收一个参数,作为值拷贝
        go func(v) {
            fmt.Println(v)
        }(v)
    }
    select {} //用select阻塞main退出
}

⼀ write a program, get the current time, and formatted into a form 2017/06/15 08:05:00

package main

import (
    "fmt"
    "time"
)

func main() {
    now := time.Now()
    //通过now.Format格式化时间
    fmt.Println(now.Format("2006/01/02 15:04:05"))
}

⼀ write a program, and start trekking time-consuming statistical ⼀ piece of code, the unit accurate to microseconds.

package main

import (
    "fmt"
    "time"
)

/*
1秒=1000毫秒(ms)

1秒=1,000,000 微秒(μs)

1秒=1,000,000,000 纳秒(ns)
*/
func Task() {
    start := time.Now().UnixNano()   //返回当前的纳秒数
    time.Sleep(5 * time.Millisecond) //睡眠5毫秒
    end := time.Now().UnixNano()
    cost := (end - start) / 1000 //换算成us微秒
    fmt.Printf("do task spend:%d us \n", cost)
}

func main() {
    Task()
}

99 multiplication table

func testMulti() {
    //有9行,每行有同等数的列
    //i代表行
    for i := 1; i < 10; i++ {
        //j代表列,从1开始,等同于行数
        for j := 1; j <= i; j++ {
            fmt.Printf("%d * %d = %d\t", j, i, j*i)
        }
        fmt.Println()
    }
}

⼀ write a program, files on the British text string into a string in reverse order ⾏ trekking

func testReverString() {
    var str = "hello超哥"
    //对字符串操作,反转含有中文的字符串,转化为rune切片,rune切片存的是单个字符,而byte切片存单个字节
    var r []rune = []rune(str)
    //遍历rune切片,每次交换头尾2个值,因此只需要交换长度的一半
    fmt.Println(len(r)) //默认rune切片长度是7
    fmt.Printf("%c\n", r)
    for i := 0; i < len(r)/2; i++ {
        //因为索引是从0开始,因此长度要减一
        //每次交换,头尾交换数据,交换5次
        r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾,r[len(r)-i-1]是尾巴索引,交换给头索引,也就是9换0,8换1,7换2,6换3,5换4
        fmt.Printf("%c\n", r)
    }
    str = string(r)
    fmt.Printf("%s\n", str)
}

⼀ write a program to determine whether the string is a string ⼀ files back to text.

func isHuiwen(str string) bool {
    //对字符串操作,反转含有中文的字符串,转化为rune切片,rune切片存的是单个字符,而byte切片存单个字节
    var r []rune = []rune(str)
    //遍历rune切片,每次交换头尾2个值,因此只需要交换长度的一半
    fmt.Println(len(r)) //默认rune切片长度是7
    for i := 0; i < len(r)/2; i++ {
        //因为索引是从0开始,因此长度要减一
        //每次交换,头尾交换数据,交换5次
        r[len(r)-i-1], r[i] = r[i], r[len(r)-i-1] //交换头尾,r[len(r)-i-1]是尾巴索引,交换给头索引,也就是9换0,8换1,7换2,6换3,5换4
    }
    str1 := string(r)
    if str1 == str {
        return true
    }
    //这里由于 golint对代码的静态检查,因此不需要写else,直接return false即可
    return false

}

func main() {
    b := isHuiwen("上海自来水来自海上")
    fmt.Println(b)
}

Find all prime numbers within the 1 to 100, and printed to the screen

//质数p,又称素数(prime),指在大于1的自然数中,除了1和该数自身外,无法被其他自然数整除的数
//求1-100的质数,
func justify(n int) bool {
    //对传入的数值判断
    //如果小于等于1直接判断false
    if n <= 1 {
        return false
    }
    //循环判断2-100是否为素数
    //此时i是除数,n是被除数
    for i := 2; i < n; i++ {
        //如果余数可以为0,代表可以被整除,也就不符合素数的概念
        if n%i == 0 {
            return false
        }
    }
    return true
}
func test() {
    //循环1-200的数,排除1
    for i := 2; i < 100; i++ {
        if justify(i) == true {
            fmt.Printf("%d is prime\n", i)
        }
    }
}

func main() {
    test()
}

Seeking narcissistic number 100-1000

func isShuixianhua(n int) bool {
    //个位数,一个数对10求模就是获取该数的个位数,例如153%10的值是3
    first := n % 10
    //十位数
    second := (n / 10) % 10
    //百位数
    third := (n / 100) % 10
    //水仙花数
    sum := first*first*first + second*second*second + third*third*third
    if sum == n {
        return true
    }
    return false
}
func main() {
    //遍历100-1000之间
    for i := 100; i < 1000; i++ {
        if isShuixianhua(i) == true {
            fmt.Printf("%d 是水仙花数\n", i)
        }
    }
}

START input characters into ⼀ a ⾏ trekking, respectively, you can count the number of text files ⺟ female English, spaces, numbers and other characters wherein

func calc(str string) (charCount int, numCount int, spaceCount int, otherCount int) {
    //遍历统计字符串,需要转换为rune切片,进行挨个判断,如果是某一个类型,计数器就加一
    utfChars := []rune(str)
    for i := 0; i < len(utfChars); i++ {
        if utfChars[i] >= 'a' && utfChars[i] <= 'z' || utfChars[i] >= 'A' && utfChars[i] <= 'Z' {
            charCount++
            continue
        }

        if utfChars[i] >= '0' && utfChars[i] <= '9' {
            numCount++
            continue
        }

        if utfChars[i] == ' ' {
            spaceCount++
            continue
        }

        otherCount++
    }
    return
}
func main() {
    var str string = "我爱北京天安门  10000年"
    charCount, numCount, spCount, other := calc(str)
    fmt.Printf("char count:%d | num count:%d | sp count:%d | other:%d\n", charCount, numCount, spCount, other)
}

Insertion Sort

//插入排序
func insert_sort(a [8]int)[8]int{
    for i:=1;i<len(a);i++{
        for j:=i;j>0;j--{ if a[j]<a[j-1]{ a[j],a[j-1]=a[j-1],a[j] }else { break } } } return a } 

Selection Sort

func select_sort(a [8]int)[8]int{
    for i:=0;i<len(a);i++{
        for j:=i+1;j<len(a);j++{
            if a[j]<a[i]{
                a[i],a[j]=a[j],a[i]
            }
        }
    }
    return a
}

Bubble Sort

func bubble_sort(a [8]int) [8]int {
    for i := 0; i < len(a); i++ {
        for j := 0; j < len(a)-i-1; j++ {
            if a[j] > a[j+1] {
                a[j], a[j+1] = a[j+1], a[j]
            }
        }
    }
    return a
}

Require that all elements of the array and


//求数组所有元素之和
func sumArray(r [10]int) int {
    var sum int
    for _, v := range r {
        sum += v
    }
    return sum
}

//随机生成一个长度10的数组
func testArray() {
    //通过随机数种子生成值,否则rand.Intn总是一个固定的随机数
    rand.Seed(time.Now().Unix())
    var b [10]int
    for i := 0; i < len(b); i++ {
        b[i] = rand.Intn(100)
    }
    fmt.Println(b)
    sum := sumArray(b)
    fmt.Println(sum)
}

func main() {
    testArray()
}

Following determination result output

func main() {
    var sa = make([]string, 5, 10)
    fmt.Println(sa) //默认有5个空元素的切片
    //循环写入十个元素,sa切片自动扩容
    for i := 0; i < 10; i++ {
        //追加是从第六个元素追加
        sa = append(sa, fmt.Sprintf("%v", i))
        fmt.Printf("长度%d,容量%d 内容%v\n", len(sa), cap(sa), sa)
    }
    fmt.Println(sa)
}

result

yugoMBP:lesson1 yuchao$ go run main.go 
[    ]
长度6,容量10 内容[     0]
长度7,容量10 内容[     0 1]
长度8,容量10 内容[     0 1 2]
长度9,容量10 内容[     0 1 2 3]
长度10,容量10 内容[     0 1 2 3 4]
长度11,容量20 内容[     0 1 2 3 4 5]
长度12,容量20 内容[     0 1 2 3 4 5 6]
长度13,容量20 内容[     0 1 2 3 4 5 6 7]
长度14,容量20 内容[     0 1 2 3 4 5 6 7 8]
长度15,容量20 内容[     0 1 2 3 4 5 6 7 8 9]
[     0 1 2 3 4 5 6 7 8 9]

Sorting array package with golangsort


func pkgSort() {
    // s1 := []int{3, 6, 5, 7, 8, 1} //声明初始化切片
    var a [5]int = [5]int{5, 4, 3, 2, 1}
    sort.Ints(a[:])
    fmt.Println("a:", a)

    var b [5]string = [5]string{"ac", "ec", "be", "fa", "ii"}
    sort.Strings(b[:])
    fmt.Println("b:", b)

    var c [5]float64 = [5]float64{29.38, 22.32, 0.8, 99191.2}
    sort.Float64s(c[:])

    fmt.Println("c:", c)
}

⼀ implement a password generation ⼯ ⽣ tool, supports the following functions a user may specify the length ⽣ ⻓ password prompt generated by -l: Use standard package may be "flag" parse command parameter ⾏ trekking

The user can specify the character set ⽣ password generated by -t, ⽐ such -t num ⽣ generate a full-digit password with a password generated -t char ⽣ UK character text files, -t mix comprising generating digital and ⽣ English text password files , -t advance ⽣ generate contain numbers, special characters and English text files password

package main

import (
    "flag"
    "fmt"
    "math/rand"
    "time"
)

var (
    length  int
    charset string
)

//密码策略,数字字母,特殊符号
const (
    NumStr  = "0123456789"
    CharStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
    SpecStr = "+=-@#~,.[]()!%^*$"
)

//解析用户输入
func parseArgs() {
    //传入整数,参数密码长度,参数名字,参数长度默认值,帮助信息
    flag.IntVar(&length, "l", 16, "-l 生成密码的长度")
    //传入的是字符串,解析哪些参数
    // 注意``用法,保证字符串原样输出
    flag.StringVar(&charset, "t", "num",
        `-t 制定密码生成的字符集, 
    num:只使用数字[0-9], 
    char:只使用英文字母[a-zA-Z], 
    mix: 使用数字和字母, 
    advance:使用数字、字母以及特殊字符`)
    //指定选项之后,确认解析
    flag.Parse()
}

func test1() {
    for i := 0; i < len(CharStr); i++ {
        //如果字符串不为空,就输出信息
        if CharStr[i] != ' ' {
            fmt.Printf("%c", CharStr[i])
        }
    }

}

//生成密码 函数
func generatePasswd() string {
    //初始化密码,存为切片,字符是byte,因此是[]byte,容量是用户指定的
    var passwd []byte = make([]byte, length, length)
    var sourceStr string
    //如果类型是num,返回数字常量,密码就是一堆数字
    if charset == "num" {
        sourceStr = NumStr
        //或者是一个字符
    } else if charset == "char" {
        sourceStr = CharStr
        //或者是混合型的
    } else if charset == "mix" {
        sourceStr = fmt.Sprintf("%s%s", NumStr, CharStr)
        //如果是高级的,数字,字母,特殊符号
    } else if charset == "advance" {
        sourceStr = fmt.Sprintf("%s%s%s", NumStr, CharStr, SpecStr)
        //如果用户输入错了,则默认返回数字密码
    } else {
        sourceStr = NumStr
    }
    //打印原始字符信息
    // fmt.Println("source:", sourceStr)
    //判断用户输入参数 -l
    for i := 0; i < length; i++ {
        //循环取得随机数
        index := rand.Intn(len(sourceStr))
        //将随机数写入到密码切片中
        passwd[i] = sourceStr[index]
    }
    return string(passwd)
}

func main() {
    //随机数种子
    rand.Seed(time.Now().UnixNano())
    //解析用户输入的参数
    parseArgs()
    //什么都不加,显示默认参数
    // fmt.Printf("length:%d charset:%s\n", length, charset)
    //生成随机数密码
    passwd := generatePasswd()
    fmt.Println(passwd)
}

⼀ a write function, a pass START into ⼀ int type pointer, and modify the values ​​in the function pointed to

func testPtr(n *int) {
    *n = 666
}
func main() {
    n := 200
    testPtr(&n)
    fmt.Println(n)
}

⼀ write a program, a number of statistical ⼀ string strings each word appears. ⽐ example: s = "how do you do" Output how = 1 do = 2 you = 1


//单词次数统计,返回map类型,key=单词,value=次数
func wordCount(str string) map[string]int {
    //初始化map,存放结果
    var result = make(map[string]int, 128)
    //对用户的输入,通过空格分割,区分单词,返回值是个切片
    words := strings.Split(str, " ")
    //遍历切片
    for _, v := range words {
        //ok是对map中的数据判断,count是map的值,也就是统计单词的次数
        count, ok := result[v]
        //如果不存在,添加一次统计
        if !ok {
            result[v] = 1

        } else {
            //如果已经存在了,value的数值+1
            result[v] = count + 1
        }
    }
    return result
}
func main() {
    str := "I am a boy. I have a apple."
    result := wordCount(str)
    //%v 输出默认值  %#v 输出完全的go语法格式
    fmt.Printf("result:%#v\n", result)
}

⼀ write a program to achieve storage ⽣ school student information, school students have ⽣ id, years of age, scores and other information. ⽅ need comes in handy very easy to find the information they are learning ⽣ students through the corresponding id.


func testInterface() {
    //空接口可以接受任意值
    var a interface{}
    var b int = 100
    var c float32 = 1.2
    var d string = "hello"

    a = b
    fmt.Printf("a=%#v %T\n", a, a)

    a = c
    fmt.Printf("a=%#v %T\n", a, a)

    a = d
    fmt.Printf("a=%#v %T\n", a, a)
}

//写⼀一个程序,实现学⽣生信息的存储,学⽣生有id、年年龄、分数等信息。需要⾮非常⽅方 便便的通过id查找到对应学⽣生的信息。
func studentStore() {
    /*声明map类型,用它存储k-v形式数据 最合适不过
    格式
    学号id [年纪:18 id:1 名字:阿狗 socre:99.9]
    转化为map
    */
    //有一处map的类型是interface{},可以存储任何类型值,如int,string,float
    //初始化第一层的map,注意内层map还需继续初始化方可使用
    var stuMap = make(map[int]map[string]interface{}, 16)
    // //创建一条学生信息
    // id := 1
    // name := "阿狗"
    // score := 88.9
    // age := 18
    // //插入第一个学生的数据,如果学生不存在,就插入数据,必须得初始化方可使用
    // value, ok := stuMap[id]
    // //如果插入失败,是因为要对map进行初始化才能使用
    // if !ok {
    //     value = make(map[string]interface{}, 8)
    // }
    // value["name"] = name
    // value["id"] = id
    // value["score"] = score
    // value["age"] = age
    // //设置第一条数据
    // stuMap[id] = value
    // fmt.Printf("stuMap: %v\n", stuMap)

    //循环十条记录写入
    for i := 0; i < 10; i++ {
        value, ok := stuMap[i]
        if !ok {
            //如果值不存在,必须要初始化
            value = make(map[string]interface{}, 8)
        }
        //Sprintf接收格式化输出,返回字符串
        value["name"] = fmt.Sprintf("stu%d", i)
        value["id"] = i
        //返回随机的浮点数据
        value["score"] = rand.Float32() * 100.0
        value["age"] = rand.Intn(100) //随机返回100以内的年纪数字
        stuMap[i] = value
    }
    fmt.Println()
    //遍历取出所有学生成绩
    for k, v := range stuMap {
        fmt.Printf("学生id=%d 学生信息=%v\n", k, v)
    }
    //学生6号的信息
    info, ok := stuMap[6]
    if ok {
        fmt.Printf("学生%d号的 姓名:%s 成绩:%f 年纪:%d", info["id"], info["name"], info["score"], info["age"])
    }
    fmt.Println()
}

func main() {
    //testInterface()
    studentStore() //所有学生成绩
    //取出学生成绩
}

You have 50 ⾦ gold coins, you need to assign the following to get accustomed to a few people Face: Matthew, Sarah, Augustus, Heidi, Emilie, Peter, Giana, Adriano, Aaron, Elizabeth.

Allocation rules are as follows:. A name contains 'a' or 'A':. 1 Mei ⾦ name contains gold coins b 'e' or 'E':. 1 Mei ⾦ name contains gold coins c 'i' or 'I':. 2 Mei ⾦ gold coins d name contains 'o' or 'O':. 3 Mei ⾦ gold coins e name contains 'u' or 'U': 5 Mei ⾦ gold coins write ⼀ a program , Using calculated for each user assigned a number ⾦ gold coins, gold coins and how much ⾦ last remaining?

package main

import "fmt"

//定义50个金币
var (
    coins = 50
    //用户信息存入一个切片,声明且初始化
    users = []string{
        "Matthew", "Sarah", "Augustus", "Heidi", "Emilie",
        "Peter", "Giana", "Adriano", "Aaron", "Elizabeth",
    }
    //分配distribution,根据用户个数分配
    distribution = make(map[string]int, len(users))
)

//计算金币,参数用户名字,计算个人的金币数量
func calcCoin(username string) int {
    var sum int = 0
    for _, char := range username {
        switch char {
        case 'a', 'A':
            sum++
        case 'e', 'E':
            sum++
        case 'i', 'I':
            sum += 2
        case 'o', 'O':
            sum += 3
        case 'u', 'U':
            sum += 5
        }
    }
    return sum
}

//分配金币
func dispathchCoin() int {
    var left = coins //定义剩余金币数
    //遍历users切片,计算金币
    for _, username := range users {
        allCoin := calcCoin(username)
        //计算剩余金币
        left -= allCoin
        value, ok := distribution[username]
        if !ok {
            distribution[username] = allCoin
        } else {
            distribution[username] = value + allCoin
        }
    }
    return left
}

func main() {
    left := dispathchCoin() //剩余金币数
    //遍历map
    for username, coin := range distribution {
        fmt.Printf("用户:\t%s\t拥有\t%d\t金币\n", username, coin)
    }
    fmt.Printf("剩余金币总数:%d\n", left)
}

Go scope pit, say the following output

package main

import (
    "fmt"
)

//全局变量
var (
    Ga int = 99
)

const (
    v int = 199
)

func GetGa() func() int {

    if Ga := 55; Ga < 60 {
        fmt.Println("GetGa if 中:", Ga)
    }

    for Ga := 2; ; {
        fmt.Println("GetGa循环中:", Ga)
        break
    }
    //这里用全局变量
    fmt.Println("GetGa函数中:", Ga)
    //闭包函数,匿名函数func()对全局Ga的引用,第一次调用是99+1,第二次是100+1,第三次是101+1,第四次是102+1
    return func() int {
        Ga += 1
        return Ga
    }
}

func main() {
    Ga := "string"
    fmt.Println("main函数中:", Ga)

    b := GetGa()
    fmt.Println("main函数中:", b(), b(), b(), b())

    v := 1 //main函数体中局部变量
    //隐式代码块,有自己局部作用域
    {
        v := 2
        fmt.Println(v)
        {
            v := 3
            fmt.Println(v)
        }
    }
    fmt.Println(v)
}

result

yugoMBP:golesson yuchao$ go run main.go 
main函数中: string
GetGa if 中: 55
GetGa循环中: 2
GetGa函数中: 99
main函数中: 100 101 102 103
2
3
1

Explanation

Ga作为全局变量纯在是int类型,值为99;而在main()中时,Ga通过简式声明 := 操作,是string类型,值为string。在main()中,v很典型地体现了在“{}”花括号中的作用域问题,每一层花括号,都是对上一层的屏蔽。而闭包函数,GetGa()返回的匿名函数,赋值给b,每次执行b(),Ga的值都被记忆在内存中,下次执行b()的时候,取b()上次执行后Ga的值,而不是全局变量Ga的值,这就是闭包函数可以使用包含它的函数内的变量,因为作为代码块一直存在,所以每次执行都是在上次基础上运行。
简单总结如下:
有花括号"{ }"一般都存在作用域的划分;
:= 简式声明会屏蔽所有上层代码块中的变量(常量),建议使用规则来规范,如对常量使用全部大写,而变量尽量小写;
在if等语句中存在隐式代码块,需要注意;
闭包函数可以理解为一个代码块,并且他可使用包含它的函数内的变量;

注意,简式变量只能在函数内部声明使用,但是它可能会覆盖函数外全局同名变量。而且你不能在一个单独的声明中重复声明一个变量,但在多变量声明中这是允许的,而且其中至少要有一个新的声明变量。重复变量需要在相同的代码块内,否则你将得到一个隐藏变量。
如果你在代码块中犯了这个错误,将不会出现编译错误,但应用运行结果可能不是你所期望。所以尽可能避免和全局变量同名。
 

Guess you like

Origin www.cnblogs.com/open-yang/p/11256975.html