Golang语言(打卡✏️第三天)map、递归、报错和练习题|Go主题月

简介: Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据,key 类似于索引,指向数据的值。Map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过,Map 是无序的,我们无法决定它的返回顺序,这是因为 Map 是使用 hash 表来实现的。


Map(集合)



Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据,key 类似于索引,指向数据的值。


Map 是一种集合,所以我们可以像迭代数组和切片那样迭代它。不过,Map 是无序的,我们无法决定它的返回顺序,这是因为 Map 是使用 hash 表来实现的。

声明变量,默认 map 是 nil


var hash map[int]int

使用 make 函数


hash:=make(map[int]int)

实例:


country:=make(map[string]string)
country["China"] = "中国"
country["Japan"] = "日本"
fmt.Println(country) //map[China:中国 Japan:日本]


delete


country:=make(map[string]string)
country["China"] = "中国"
country["Japan"] = "日本"
delete(country,"Japan")
fmt.Println(country) //map[China:中国


递归函数



递归,就是在运行的过程中调用自己。


实例1:阶乘


var i int =5
fmt.Println(factorial(i)) //120
func factorial(n int)int{
    if n>0{
        return  n*factorial(n-1)
    }
    return 1
}


实例2:生成斐波那契数列

var i int = 5
fmt.Println(fibonacci(i)) //5
func fibonacci(n int)int{
    if n<2{
        return n
    }
    return fibonacci(n-1)+fibonacci(n-2)
}
var user Users
user = new(User)
user.call()
user = new(Vip)
user.call()
type Users interface {
    call()
}
type User struct {
}
type Vip struct {
}
func (vip,Vip) call() {
    fmt.Println("Vip User")
}
func (user User) call() {
    fmt.Println("User")
}


错误处理



Go 语言通过内置的错误接口提供了非常简单的错误处理机制。


result, err:= Sqrt(-1)
if err != nil {
   fmt.Println(err)
}


定义报错接口


type error interface {
    Error() string
}
func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("不能为负数")
    }
    return error
}


GOlang练习题



1.四个数进行排列组合。


有 1、2、3、4 这四个数字,能组成多少个互不相同且无重复数字的三位数?都是多少?


func threeTotal()int{
    ret:=0
    for i:=1;i<5;i++{
        for k:=1;k<5;k++{
            for j:=1;j<5;j++{
                if i!=k && k!=j && j!=i{
                    ret++
                    fmt.Println("组成的组合有i=",i,",k=",k,",j=",j)
                }
            }
        }
    }
    return ret
}
threeTotal() //24
// 组成的组合有i= 1 ,k= 2 ,j= 3
// 组成的组合有i= 1 ,k= 2 ,j= 4
// 组成的组合有i= 1 ,k= 3 ,j= 2
// 组成的组合有i= 1 ,k= 3 ,j= 4
// 组成的组合有i= 1 ,k= 4 ,j= 2
// 组成的组合有i= 1 ,k= 4 ,j= 3
// 组成的组合有i= 2 ,k= 1 ,j= 3
// 组成的组合有i= 2 ,k= 1 ,j= 4
// 组成的组合有i= 2 ,k= 3 ,j= 1
// 组成的组合有i= 2 ,k= 3 ,j= 4
// 组成的组合有i= 2 ,k= 4 ,j= 1
// 组成的组合有i= 2 ,k= 4 ,j= 3
// 组成的组合有i= 3 ,k= 1 ,j= 2
// 组成的组合有i= 3 ,k= 1 ,j= 4
// 组成的组合有i= 3 ,k= 2 ,j= 1
// 组成的组合有i= 3 ,k= 2 ,j= 4
// 组成的组合有i= 3 ,k= 4 ,j= 1
// 组成的组合有i= 3 ,k= 4 ,j= 2
// 组成的组合有i= 4 ,k= 1 ,j= 2
// 组成的组合有i= 4 ,k= 1 ,j= 3
// 组成的组合有i= 4 ,k= 2 ,j= 1
// 组成的组合有i= 4 ,k= 2 ,j= 3
// 组成的组合有i= 4 ,k= 3 ,j= 1
// 组成的组合有i= 4 ,k= 3 ,j= 2


2.企业发放的奖金根据利润提成的计算


企业发放的奖金根据利润提成。利润(I)低于或等于 10 万元时,奖金可提成 10%;利润高于 10 万元,低于 20 万元,低于 10 万元的部分按 10% 提成,高于 10 万元的部分,可提成 7.5%。20 万到 40 万之间时,高于 20 万元的部分,可提成 5%;40 万到 60 万之间时高于 40 万元的部分,可提成 3%;60 万到 100 万之间时,高于 60 万元的部分,可提成 1.5%,高于 100 万元时,超过 100 万元的部分按 1% 提成。从键盘输入当月利润 I,求应发放奖金总数?


func fundSum()float32 {
    var I float32 = 0.0
    var bonus float32 = 0.0
    fmt.Print("输入利润:")
    fmt.Scanf("%f\n", &I)
    switch{
    case I > 1000000:
        bonus = (I - 1000000) * 0.01
        I = 1000000
        fallthrough
    case I > 600000:
        bonus += (I - 600000) * 0.015
        I = 600000
        fallthrough
    case I > 400000:
        bonus += (I - 400000) * 0.03
        I = 400000
        fallthrough
    case I > 200000:
        bonus += (I - 200000) * 0.05
        I = 200000
        fallthrough
    case I > 100000:
        bonus += (I - 100000) * 0.075
        I = 100000
        fallthrough
    default:
        bonus += I * 0.1
    }
    fmt.Printf("奖金总额为%f\n",bonus)
    return bonus
}
fundSum()
//输入利润:888222
//奖金总额为37823.328125


3.计算完全平方数


一个整数,它加上 100 后是一个完全平方数,再加上 168 又是一个完全平方数,请问该数是多少?


func perfectSqure()int{
    i:=0
    for {    
        x :=int(math.Sqrt(float64(i+100)))
        y :=int(math.Sqrt(float64(i+100+168)))
        if x*x ==(i+100) && y*y == (i+100+168){
            fmt.Printf("该数是%d\n",i)
            return i
        }
        i++
    }
}
fmt.Println(perfectSqure())  //该数是21


4.数字从小到大排序


输入三个 整数 x,y,z,请把这三个数由小到大输出。


func threeCompare(){
    var a,b,c int=0,0,0
    fmt.Scanf("%d%d%d",&a,&b,&c)
    if a>b {
       a,b = b,a
    } 
    if a>c{
       a,c = c,a
    } 
    if b>c{
       b,c = c,b
    }
    fmt.Printf("%d<%d<%d",a,b,c)
}
threeCompare()
//2123 23232 123
//123<2123<23232


5.打印字母 C。


func printC(){
    var a, b = 176, 219
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, a, b, b, b, a, a,a)
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, b, a, a, a, b, a,a)
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, b, a, a, a, a, a,a)
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, b, a, a, a, a, a,a)
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, a, b, a, a, b, a,a)
    fmt.Printf("%c%c%c%c%c%c%c%c \n", a, a, a, b, b, a, a,a)
}
printC()


6.找出数组中的幸运数


在整数数组中,如果一个整数的出现频次和它的数值大小相等,我们就称这个整数为「幸运数」。给你一个整数数组 arr,请你从中找出并返回一个幸运数。


package main
import "fmt"
func main()  {
    nums := []int{1,2,3,4}
    ret:=find132pattern(nums)
    fmt.Println(ret)
}
func findLucky(arr []int) int {
   //定义哈希变量
    hash:=make(map[int]int) 
    for _,j:=range arr{
    //记录元素出现的次数
        hash[j]++
    }
    ret:=-1
    for i,j:=range hash{
        //找到最大次数和值相等的情况
        if i==j && ret<i{
            ret=i
        }
    }
    return ret 
}
相关文章
|
5天前
|
分布式计算 Java Go
Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
【5月更文挑战第6天】Apache Beam是一个统一的编程模型,适用于批处理和流处理,主要支持Java和Python,但也提供实验性的Go SDK。Go SDK的基本概念包括`PTransform`、`PCollection`和`Pipeline`。在使用中,需注意类型转换、窗口和触发器配置、资源管理和错误处理。尽管Go SDK文档有限,生态系统尚不成熟,且性能可能不高,但它仍为分布式计算提供了可移植的解决方案。通过理解和掌握Beam模型,开发者能编写高效的数据处理程序。
141 1
|
5天前
|
缓存 测试技术 持续交付
Golang深入浅出之-Go语言中的持续集成与持续部署(CI/CD)
【5月更文挑战第5天】本文介绍了Go语言项目中的CI/CD实践,包括持续集成与持续部署的基础知识,常见问题及解决策略。测试覆盖不足、版本不一致和构建时间过长是主要问题,可通过全面测试、统一依赖管理和利用缓存优化。文中还提供了使用GitHub Actions进行自动化测试和部署的示例,强调了持续优化CI/CD流程以适应项目需求的重要性。
55 1
|
5天前
|
Kubernetes Cloud Native Go
Golang深入浅出之-Go语言中的云原生开发:Kubernetes与Docker
【5月更文挑战第5天】本文探讨了Go语言在云原生开发中的应用,特别是在Kubernetes和Docker中的使用。Docker利用Go语言的性能和跨平台能力编写Dockerfile和构建镜像。Kubernetes,主要由Go语言编写,提供了方便的客户端库与集群交互。文章列举了Dockerfile编写、Kubernetes资源定义和服务发现的常见问题及解决方案,并给出了Go语言构建Docker镜像和与Kubernetes交互的代码示例。通过掌握这些技巧,开发者能更高效地进行云原生应用开发。
58 1
|
5天前
|
负载均衡 监控 Go
Golang深入浅出之-Go语言中的服务网格(Service Mesh)原理与应用
【5月更文挑战第5天】服务网格是处理服务间通信的基础设施层,常由数据平面(代理,如Envoy)和控制平面(管理配置)组成。本文讨论了服务发现、负载均衡和追踪等常见问题及其解决方案,并展示了使用Go语言实现Envoy sidecar配置的例子,强调Go语言在构建服务网格中的优势。服务网格能提升微服务的管理和可观测性,正确应对问题能构建更健壮的分布式系统。
30 1
|
5天前
|
消息中间件 Go API
Golang深入浅出之-Go语言中的微服务架构设计与实践
【5月更文挑战第4天】本文探讨了Go语言在微服务架构中的应用,强调了单一职责、标准化API、服务自治和容错设计等原则。同时,指出了过度拆分、服务通信复杂性、数据一致性和部署复杂性等常见问题,并提出了DDD拆分、使用成熟框架、事件驱动和配置管理与CI/CD的解决方案。文中还提供了使用Gin构建HTTP服务和gRPC进行服务间通信的示例。
29 0
|
5天前
|
监控 算法 Go
Golang深入浅出之-Go语言中的服务熔断、降级与限流策略
【5月更文挑战第4天】本文探讨了分布式系统中保障稳定性的重要策略:服务熔断、降级和限流。服务熔断通过快速失败和暂停故障服务调用来保护系统;服务降级在压力大时提供有限功能以保持整体可用性;限流控制访问频率,防止过载。文中列举了常见问题、解决方案,并提供了Go语言实现示例。合理应用这些策略能增强系统韧性和可用性。
52 0
|
5天前
|
Prometheus 监控 Cloud Native
Golang深入浅出之-Go语言中的分布式追踪与监控系统集成
【5月更文挑战第4天】本文探讨了Go语言中分布式追踪与监控的重要性,包括追踪的三个核心组件和监控系统集成。常见问题有追踪数据丢失、性能开销和监控指标不当。解决策略涉及使用OpenTracing或OpenTelemetry协议、采样策略以及聚焦关键指标。文中提供了OpenTelemetry和Prometheus的Go代码示例,强调全面可观测性对微服务架构的意义,并提示选择合适工具和策略以确保系统稳定高效。
36 5
|
5天前
|
负载均衡 算法 Go
Golang深入浅出之-Go语言中的服务注册与发现机制
【5月更文挑战第4天】本文探讨了Go语言中服务注册与发现的关键原理和实践,包括服务注册、心跳机制、一致性问题和负载均衡策略。示例代码演示了使用Consul进行服务注册和客户端发现服务的实现。在实际应用中,需要解决心跳失效、注册信息一致性和服务负载均衡等问题,以确保微服务架构的稳定性和效率。
22 3
|
5天前
|
前端开发 Go
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式
【5月更文挑战第3天】Go语言通过goroutines和channels实现异步编程,虽无内置Future/Promise,但可借助其特性模拟。本文探讨了如何使用channel实现Future模式,提供了异步获取URL内容长度的示例,并警示了Channel泄漏、错误处理和并发控制等常见问题。为避免这些问题,建议显式关闭channel、使用context.Context、并发控制机制及有效传播错误。理解并应用这些技巧能提升Go语言异步编程的效率和健壮性。
30 5
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式
|
5天前
|
监控 负载均衡 算法
Golang深入浅出之-Go语言中的协程池设计与实现
【5月更文挑战第3天】本文探讨了Go语言中的协程池设计,用于管理goroutine并优化并发性能。协程池通过限制同时运行的goroutine数量防止资源耗尽,包括任务队列和工作协程两部分。基本实现思路涉及使用channel作为任务队列,固定数量的工作协程处理任务。文章还列举了一个简单的协程池实现示例,并讨论了常见问题如任务队列溢出、协程泄露和任务调度不均,提出了解决方案。通过合理设置缓冲区大小、确保资源释放、优化任务调度以及监控与调试,可以避免这些问题,提升系统性能和稳定性。
28 6