• Go语言开发实战课后编程题

    Go语言开发实战课后编程题

    自己做的课后习题，不保证完全正确，侵删

    第一章

    尝试创建一个项目，新建一个程序，输出字符串“我爱Go语言”。

    package main

import "fmt"

func main(){
    fmt.Println("我爱Go语言")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    输出结果：
    在这里插入图片描述

    第三章

    打印左上直角三角形

    package main

import "fmt"

func main(){
    // 读入需要生成多少行的左上直角三角形
    var line int
    fmt.Scanf("%d",&line)

    // 生成左上直角三角形
    for i := 0;i < line;i++{
        for j:=0;j < (line - i);j++{
            fmt.Printf("*")
        }
        fmt.Println()
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出结果：
    在这里插入图片描述

    编程打印出所有的“水仙花数”。所谓水仙花数，是指一个三位数，其各位数字的立方之和等于该数

    package main

import "fmt"

func main(){
    var a,b,c int
    for num := 100;num < 1000;num++{
        a = num / 100
        b = (num - 100 * a) / 10
        c = num % 10
        if (a * a * a + b * b * b + c * c * c) == num{
            fmt.Println(num)
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    输出结果：
    在这里插入图片描述

    第四章

    斐波那契数列是由0和1开始，之后的斐波那契数列系数就由之前的两数相加。在数学上定义为F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)，下面请使用闭包实现斐波那契数列，并输出前10个数

    package main

import "fmt"

func fib() func() int {
    var f0 int = 0
    var f1 int = 1
    return func() int{
        tmp := f0
        f0 = f1
        f1 = f0 + tmp
        return tmp
    }
}

func main(){
    myfib := fib()
    for i := 0;i < 10;i++{
        fmt.Println(myfib())
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    输出结果：
    在这里插入图片描述

    递归实现n!

    package main

import "fmt"

func factorial(n int) int {
    if n == 0{
        return 1
    }
    return n * factorial(n - 1)
}


func main(){
    var num int
    fmt.Scanf("%d",&num)
    fmt.Printf("%d\n",factorial(num))
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出结果：
    在这里插入图片描述

    第五章

    实现杨辉三角输出（打印10行）

    package main

import "fmt"

func calYangHuiTriangle(arr []int) []int{
    arrlen := len(arr)
    ret := []int{}
    if arrlen == 0{ //说明是杨辉三角的第一行
        ret = append(ret,1) // 返回第一行
        return ret
    }
    // 首先在ret中添加1
    ret = append(ret,1)
    // 添加中间的值
    for i := 0; i < arrlen - 1;i++{
        ret = append(ret,arr[i] + arr[i + 1])
    }
    // 添加最后的1
    ret = append(ret,1)
    return ret
}

func main(){
    arr := []int{}
    for i := 0;i < 10;i++{
        arr = calYangHuiTriangle(arr)
        fmt.Println(arr)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    输出结果：
    在这里插入图片描述

    写一个函数，判断一个字符串是否对称，若对称，返回true，否则返回false

    package main

import "fmt"

func isEqual(arr string) bool{
    length := len(arr)
    i := 0
    j := length - 1
    for ;i <= j;i++{
        if arr[i] != arr[j]{
            return false
        }
        j--
    }
    return true
}

func main(){
    var arr string
    fmt.Scanf("%s",&arr)
    fmt.Println(isEqual(arr))
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    输出结果：
    在这里插入图片描述
    在这里插入图片描述

    第六章

    将字符串内所有abc替换成xyz，并转换成大写

    package main

import (
    "fmt"
    "strings"
)

func toUpperAfterSplit(arr string) string{
    splitArr := strings.Split(arr,"abc")
    var retStr string
    length := len(splitArr)
    for i := 0;i < length - 1;i++{
        retStr += (splitArr[i] + "xyz")
    }
    retStr += splitArr[length -1 ]
    retStr = strings.ToUpper(retStr)
    return retStr
}

func main(){
    var arr string
    fmt.Scanf("%s",&arr)
    fmt.Println(toUpperAfterSplit(arr))
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    // 或者可以用strings包中自带的join函数
package main

import (
    "fmt"
    "strings"
)

func toUpperAfterSplit(arr string) string{
    splitArr := strings.Split(arr,"abc")
    var retStr string
    retStr = strings.Join(splitArr,"xyz")
    retStr = strings.ToUpper(retStr)
    return retStr
}

func main(){
    var arr string
    fmt.Scanf("%s",&arr)
    fmt.Println(toUpperAfterSplit(arr))
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    输出结果：
    在这里插入图片描述

    编写一个程序，输入某个日期，输出该日期是星期几

    package main

import (
	"fmt"
	"strconv"
	"strings"
)

func calculateTheDateofTheWeek(date string) string{
    var weekday = [...]string{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
    /*
        根据蔡勒公式计算日期
        w = ([c/4]-2c+y+[y/4]+[13*(m+1)/5]+d-1)MOD7
        w —— 星期； w对7取模得：0-星期日，1-星期一，2-星期二，3-星期三，4-星期四，5-星期五，6-星期六
        c —— 世纪（注：一般情况下，在公式中取值为已经过的世纪数，也就是年份除以一百的结果，而非正在进行的世纪，也就是现在常用的年份除以一百加一）
        y —— 年（一般情况下是后两位数，如果是公元前的年份且非整百数，y应该等于cMOD100+100）
        m —— 月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算）
        d —— 日
    */
    var datetime = strings.Split(date,"-")
    var year,month,day int
    var c,y,m,index int
    year,_ = strconv.Atoi(datetime[0])
    month,_ = strconv.Atoi(datetime[1])
    day,_ = strconv.Atoi(datetime[2])
    if month < 3{
        m = month + 12
        y = (year - 1) % 100
        c = (year - 1) / 100
    }else{
        m = month
        y = year % 100
        c = year / 100
    }
    index = ((c / 4) - 2 * c + y + (y / 4) + (13 * (m + 1) / 5) + day - 1) % 7
    return weekday[index]
    
}

func main(){
    var date string
    fmt.Scanf("%s",&date)
    fmt.Println(calculateTheDateofTheWeek(date))
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    输出结果：
    在这里插入图片描述

    第七章

    自定义一个案例。该案例包含以下知识点：结构体，继承，方法重写，接口，多态，接口对象转型

    package main

import (
    "fmt"
)

/*
    定义三个-结构体-：
    （1）Human：属性有name、sex、age、phone
    （2）Teacher：属性继承Human，再添加school，systemType，salary
    （3）Employee：属性继承Human，再添加company，systemType，salary

    --方法--
    （1）采用继承和方法重写完成功能：对于Teacher和Employee，自我介绍都需要包含自己的名字、年龄、手机号，老师还需要介绍自己的工作学校
    （2）采用接口完成功能：Teacher和Employee介绍自己所使用的电脑系统类型（Windows/MAC）
    （3）采用多态完成功能：在场所有人的工资平均和总和
    （4）采用接口对象转型完成功能：判断是否是Teacher还是Employee
*/

// 结构体
type Human struct{
    name,phone,sex string
    age int
}

type Teacher struct{
    Human
    school,systemType string
    salary float64
}

type Employee struct{
    Human
    company,systemType string
    salary float64
}

// 接口
type introduceSystemType interface{
    introduceSystemType()
}

// 自我介绍方法（Human）
func (h Human) introduce(){
    fmt.Printf("大家好，我叫%s，我%d岁了，手机号为%s\n",h.name,h.age,h.phone)
}

// 自我介绍方法（Teacher）
func (t Teacher) introduce(){
    fmt.Printf("大家好，我叫%s，我%d岁了，手机号为%s，工作于%s\n",t.name,t.age,t.phone,t.school)
}

// 介绍自己所使用的电脑系统
func (t Teacher) introduceSystemType(){
    fmt.Printf("大家好，我是Teacher，我使用的电脑系统为%s\n",t.systemType)
}

func (e Employee) introduceSystemType(){
    fmt.Printf("大家好，我是Employee，我使用的电脑系统为%s\n",e.systemType)
}

// 计算工资相关
type Income interface{
    calSalary() float64
}
func (t Teacher) calSalary() float64{
    return t.salary
}

func (e Employee) calSalary() float64{
    return e.salary
}

func main(){
    // 首先新建三个Teacher和三个Employee
    t1 := Teacher{Human{"Dianel","188-4658-****","Male",26},"第一中学","Windows",5645.5}
    t2 := Teacher{Human{"Cherry","156-7894-****","Female",45},"第二中学","Windows",4569.7}
    t3 := Teacher{Human{"Helen","131-4652-****","Female",35},"第三中学","Mac",7895.3}
    e1 := Employee{Human{"Selina","156-7899-****","Female",28},"01公司","Mac",12368}
    e2 := Employee{Human{"Tom","178-4632-****","Male",39},"02公司","Mac",4569}
    e3 := Employee{Human{"Jack","198-3645-****","Male",45},"03公司","Windows",25984.6}

    // 每个人自我介绍一下
    fmt.Println("---------------------------------------------------")
    t1.introduce()
    t2.introduce()
    t3.introduce()
    e1.introduce()
    e2.introduce()
    e3.introduce()

    // 介绍自己所使用的电脑系统
    fmt.Println("---------------------------------------------------")
    t1.introduceSystemType()
    t2.introduceSystemType()
    t3.introduceSystemType()
    e1.introduceSystemType()
    e2.introduceSystemType()
    e3.introduceSystemType()

    //计算工资总和和平均
    fmt.Println("---------------------------------------------------")
    var totalSalary,averageSalary float64
    var count int
    ic := []Income{t1,t2,t3,e1,e2,e3}

    for _,income := range ic{
        if instance,ok := income.(Teacher);ok{
            fmt.Printf("我是Teacher，我的工资为%.2f\n",instance.salary)
        }else if instance,ok := income.(Employee);ok{
            fmt.Printf("我是Employee，我的工资为%.2f\n",instance.salary)
        }
        totalSalary += income.calSalary()
        count += 1
    }
    averageSalary = totalSalary / float64(count)
    
    fmt.Println("---------------------------------------------------")
    fmt.Printf("TotalSalary:%.2f\n",totalSalary)
    fmt.Printf("AverageSalary:%.2f\n",averageSalary)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121

    输出结果：
    在这里插入图片描述

    第八章

    借助defer实现字符串倒序

    package main

import (
    "fmt"
)

func main(){
    var arr string
    fmt.Scanf("%s",&arr)
   for i := 0;i < len(arr);i++{
       defer fmt.Printf("%c",arr[i])
   }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    输出结果：
    在这里插入图片描述
    其他实现方法：https://zhuanlan.zhihu.com/p/78550943

  • 相关阅读:
    【LeetCode】102. 二叉树的层序遍历
    鸿鹄工程项目管理系统 Spring Cloud+Spring Boot+前后端分离构建工程项目管理系统
    【二】2D测量 Metrology——align_metrology_model()算子
    数据可视化项目（一）
    Docker构建自定义镜像（shell为zsh）
    ADDS：卸载/降级域控制器
    Spring cloud负载均衡@LoadBalanced & LoadBalancerClient
    告警平台设计方案
    作用域与作用域链--面试题
    系统架构设计师 2023年 论文
  • 原文地址：https://blog.csdn.net/qq_41772794/article/details/125944892