3.你所不知道的go语言控制语句——Leetcode习题69

这篇具有很好参考价值的文章主要介绍了3.你所不知道的go语言控制语句——Leetcode习题69。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录
  • 本篇前瞻
  • Leetcode习题9
    • 题目描述
    • 代码编写
  • 控制结构
    • 顺序结构(Sequence)
      • 声明和赋值
      • 多返回值赋值
      • 运算符
        • 算术运算符
        • 位运算符
        • 逻辑运算
    • 分支结构
      • if 语句
      • switch 语句
        • 逻辑表达式
        • fallthrough
        • 类型推断
    • 循环语句
      • continue
      • break
      • goto
  • Leetcode习题69
    • 题目描述
    • 题目分析
    • 代码编写
  • 本篇小结
  • 下篇预告

本篇前瞻

好的,现在你已经来到一个新的小结,在这里你将学习到go语言的重要内容,习得go 25个关键字中的12个:var, const, if, else, switch, case, default, fallthrough, for, break, goto, continue,即在顺序结构学习var,const,在分支结构中学习if, else, switch, case, default, fallthrough,在循环结构中学习for, break, goto, continue。另外你最好注册一个Leetcode账号.

Leetcode习题9

让我们再来看下这个例子,这个是一个比较好的例子,里面包含了顺序,分支以及循环的所有控制结构

题目描述

9. 回文数

给你一个整数 x ,如果 x 是一个回文整数,返回 true ;否则,返回 false

回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。

代码编写

func isPalindrome(x int) bool {
	if (x < 0) { //分支结构
		return false
	}
	x64 := x   //顺序结构
	px64 := 0
	for x64 != 0 {  //循环结构
		px64 = px64*10 + x64%10 // 顺序结构
		x64 /= 10
	}
	return px64 == x 
}

你在这个道题目中能看到所有的控制结构:顺序结构,分支结构,循环机构

控制结构

顺序结构(Sequence)

声明和赋值

在顺序结构中声明和赋值是很重要的

var可以声明一个变量,而const则声明一个常量

package main

import "fmt"

func main() {
	var i1 int     //声明变量,默认值为0
	var i2 int = 1 //声明变量,初始化为1
	i3 := 2        //这是最常用的声明和初始化手段
	fmt.Println(i1, i2, i3)
	i4 := i2 + i3 //使用运算表达式赋值
	i3 *= i4      //使用运算表达式赋值
	fmt.Println(i3, i4)
	const ci1 int = 13 //声明常量,无法
	fmt.Println(ci1)
	x, y, z := 100, 101, 102 //多返回值
	fmt.Println(x, y, z)     //打印结果
}

输出:

0 1 2
6 3
13
100 101 102

这里仅仅举例了整形int的声明

多返回值赋值

x,y,z := 0,1,2

go语言允许这样多返回值赋值赋值方式,再挖个坑,原因会在介绍函数时说明一下。

运算符

算术运算符

++ --
自增1 自减1
+= -= *= /= %=
自增 自减 自乘 自除 自模,取余
+ - * / %
加法 减法 乘法 除法 模,取余

注意: 例如如3/2 在整型中是整除即3/2=1,在浮点型是3.0/2.0=1.5,模运算智能用于整数

位运算符

<< >> & | ^
左移 右移 亦或
<<= >>= &= |= ^=
自左移 自右移 自与 自或 自亦或

位运算符几乎我们这篇实用的编程用不到,但是这个概念也很重要,计算机底层事实上是这样工作的,这里在挖个坑,后面会介绍位运算的相关leetcode题目,你会看到它的威力。

逻辑运算

&& || == !=
相等 不等于
>= <= > <
大于等于 小于等于 大于 小于

这些会在分支语句中大放异彩。

分支结构

if 语句

if 语句有if,if-else以及if-else if-else结构,如下所示:

package main

import "fmt"

func main() {
	var input int
	fmt.Printf("请输入分数:")
	fmt.Scanf("%d", &input)
	if input < 60 { //if
		fmt.Println("1.不合格")
	}

	if input < 60 { //if-else
		fmt.Println("2.不合格")
	} else{
		fmt.Println("2.合格")
	}

	if input < 60 {//if-else if-else
		fmt.Println("3.不合格")
	} else if input < 70 {
		fmt.Println("3.合格")
	} else if input < 85 {
		fmt.Println("3.良好")
	} else  {
		fmt.Println("3.优秀")
	}
}

结果如下:

请输入分数:59
1.不合格
2.不合格
3.不合格

switch 语句

事实上switch 语句比if语句更为强大,在有多个分支时更为符合go语言的风格,完整代码如下:

package main

import "fmt"

func main() {
	var i int
	fmt.Printf("请输入分数:")
	fmt.Scanf("%d\n", &i)
	switch {
	case i < 60: //单个逻辑表达式
		fmt.Println("不合格")
	case i < 70:
		fmt.Println("合格")
	case i < 85:
		fmt.Println("良好")
	default:
		fmt.Println("优秀")
	}

	var c byte
	fmt.Printf("请输入等级:")
	fmt.Scanf("%c\n", &c)

	switch c {
	case 'E', 'e': //可以有多个选择
		fmt.Println("1.不合格")
	case 'D', 'd':
		fmt.Println("1.基本合格")
	case 'C', 'c':
		fmt.Println("1.合格")
	case 'B', 'b':
		fmt.Println("1.良好")
	case 'A', 'a':
		fmt.Println("1.优秀")
	default:
		fmt.Println("1.错误的输入")
	}

	switch {
	case c == 'E', c == 'e': //可以有多个表达式
		fmt.Println("2.不合格")
	case c == 'D', c == 'd':
		fmt.Println("2.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("2.合格")
	case c == 'B', c == 'b':
		fmt.Println("2.良好")
	case c == 'A', c == 'a':
		fmt.Println("2.优秀")
	default:
		fmt.Println("2.错误的输入")
	}

	switch {
	case c == 'E':
		fmt.Println("3.不合格")
		fallthrough //fallthrough会执行下一个case区块
	case c == 'e':
		fmt.Println("3.真的不合格")
	case c == 'D', c == 'd':
		fmt.Println("3.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("3.合格")
	case c == 'B', c == 'b':
		fmt.Println("3.良好")
	case c == 'A', c == 'a':
		fmt.Println("3.优秀")
	default:
		fmt.Println("3.错误的输入")
	}

	var in interface{} = i
	switch data := in.(type) { //类型推断
	case int:
		fmt.Printf("int: %v\n", data)
	case uint:
		fmt.Printf("uint: %v\n", data)
	default:
		fmt.Printf("type: %T\n", data)
	}
}

结果如下:

请输入分数:90
优秀
请输入等级:E
1.不合格
2.不合格
3.不合格
3.真的不合格
int: 90

逻辑表达式

注意case可以是单个或多个逻辑表达式

	switch {
	case c == 'E', c == 'e': //可以有多个表达式
		fmt.Println("2.不合格")。
	case c == 'D', c == 'd':
		fmt.Println("2.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("2.合格")
	case c == 'B', c == 'b':
		fmt.Println("2.良好")
	case c == 'A', c == 'a':
		fmt.Println("2.优秀")
	default:
		fmt.Println("2.错误的输入")
	}

fallthrough

fallthrough会执行下一个case区块

	switch {
	case c == 'E':
		fmt.Println("3.不合格")
		fallthrough //fallthrough会执行下一个case区块
	case c == 'e':
		fmt.Println("3.真的不合格")
	case c == 'D', c == 'd':
		fmt.Println("3.基本合格")
	case c == 'C', c == 'c':
		fmt.Println("3.合格")
	case c == 'B', c == 'b':
		fmt.Println("3.良好")
	case c == 'A', c == 'a':
		fmt.Println("3.优秀")
	default:
		fmt.Println("3.错误的输入")
	}

类型推断

这个是一个强大的方式,它可以用于推断go语言的接口的类型,不过现在只能简单那介绍一下,你可以将interface{}可以表达任何类型

	var in interface{} = i
	switch data := in.(type) { //类型推断
	case int:
		fmt.Printf("int: %v\n", data)
	case uint:
		fmt.Printf("uint: %v\n", data)
	default:
		fmt.Printf("type: %T\n", data)
	}

循环语句

循环语句只有for

package main

import "fmt"

func main() {
	var input int
	fmt.Printf("请输入分数(0-5):")
	fmt.Scanf("%d", &input)

	for i := 0; i < 5; i++ { //正常的for
		fmt.Println("loop1:", i)

		if i < 2 {
			continue //跳过本次执行
		}
		if i == input {
			fmt.Println("loop1: break") //跳出本层循环
			break
		}
	}
	i := 0
Loop:
	for i < 5 { //去掉;的for循环
		fmt.Println("loop2:", i)
		for j := 0; j < 5; j++ {
			if j == input {
				fmt.Println("loop2: break Loop") //跳出Loop标记的循环
				break Loop
			}
			if j == 1 {
				break //跳出本层循环
			}
		}
		i++
	}
	i = 0
	for ; i < 5; i++ { //空缺一个元素并带有;的for循环
		fmt.Println("loop3:", i)
		for j := 0; j < 5; j++ {
			if j < 2 {
				continue
			}
			if j == input {
				goto Exit //跳出到Exit
			}
		}
	}
	return
Exit:
	fmt.Println("loop3: Exit")
}

结果如下:

请输入分数(0-5):1
loop1: 0
loop1: 1
loop1: 2
loop1: 3
loop1: 4
loop2: 0
loop2: break Loop
loop3: 0
loop3: 1
loop3: 2
loop3: 3
loop3: 4

请输入分数(0-5):2
loop1: 0
loop1: 1
loop1: 2
loop1: break
loop2: 0
loop2: 1
loop2: 2
loop2: 3
loop2: 4
loop3: 0
loop3: Exit

continue

跳过本次循环

break

没有加标签的就是跳过本层循环

加标签的就是跳过被标签标记的循环

goto

跳到被标签标记的循环,使用goto在处理一些同意的错误或者统一的出口而降低代码的冗余,增加代码可读性。这里挖个坑,这里会在go-etl展示goto的魅力

注意:很多书籍指出goto会破环代码结构,降低代码可读性,那是因为这些书籍讲述使用goto的场景错了

Leetcode习题69

我们以leetcode习题开始,而现在有以一道Leetcode习题结束

题目描述

69. x 的平方根

给你一个非负整数 x ,计算并返回 x算术平方根

由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。

注意:不允许使用任何内置指数函数和算符,例如 pow(x, 0.5) 或者 x ** 0.5

题目分析

这道题会比Leetcode习题1更加困难些,这次数据范围是int32的非负整数范围,由于不能使用指数函数和算符,为此,在这里我们需要使用二分法,即通过二分[a,b](mid = a + (b-a)/2, 第一轮a=0,b=x)去获取mid=x/2,如果mid*mid<x 那么此时二分[a,mid-1],反之二分[mid+1,b], 这样不断二分下去直到 mid*mid=x或者a<b。好的,这样我们获得了解题思路,但是还有个问题,选择y的数据类型是什么,如果选择int32,那么相乘必然超过int32, 为此我们必须选择int64,注意:在Leetcode习题9中得出了结论,int是64位的,所以不用改为int64

代码编写

func mySqrt(x int) int {
	a, b := 0, x //多返回值赋值
	for a <= b { // 无;结构的for
		mid := a + (b-a)/2   //二分区间
		if mid*mid == x { //if语句
			return mid
		}
		if mid*mid < x { //if-else语句
			a = mid + 1   //选择较大的区间
		} else {
			b = mid - 1  //选择较小的区间
		}
	}
	return b
}

本篇小结

恭喜你已经完成了所有控制结构的学习,你以及知道了所有控制结构用到的保留字和注意点。另外,通过Leetcode习题69和Leetcode习题9,你已经知道在编程时选择数据类型的重要性,并且练习了所有控制结构。这里的相关代码放在go语言学习的go-base/3中,请下载后进行实际的练习

注意:之后的Leetcode题目解答以及使用工具的编程中,数据类型的选择以及控制结构的应用是非常重要的,也是最为基础的

下篇预告

go语言复合类型文章来源地址https://www.toymoban.com/news/detail-659392.html

到了这里,关于3.你所不知道的go语言控制语句——Leetcode习题69的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 你所不知道的 数据在内存中储存 的来龙去脉

            那么好了好了,宝子们,今天给大家介绍一下 “数据在内存中储存” 的来龙去脉,来吧,开始整活!⛳️          一、数据类型的介绍 (1)整型和浮点型:    (2)其他类型:    二、数据在内存中的储存顺序(大端 小端)   (1)引入字节序: 字节序

    2024年02月06日
    浏览(68)
  • 你所不知道的ASP.NET Core进阶系列(三)

    一年多没更新博客,上一次写此系列还是四年前,虽迟但到,没有承诺,主打随性,所以不存在断更,催更,哈哈,上一篇我们细究从请求到绑定详细原理,本篇则是探讨模型绑定细节,当一个问题产生到最终解决时,回过头我们整体分析其产生背景以及设计思路才能有所获

    2024年02月05日
    浏览(93)
  • 你所不知道的 GitHub 快捷键及实用技巧

    目录 一、 搜索 1. 快捷键 S 或 / , 聚焦搜索栏 2. 高级搜索 2.1 按 star 数查询 2.2 按 fork 数查询 2.3 按 topic 数查询 2.4 按时间查询 2.5 按作者查询 2.6 排除特定内容 二、网页快捷键 1. GitHub 全局快捷键 1.1 快捷键 S 或 / , 聚焦搜索栏 1.2 快捷键 G + N,跳转到消息页 1.3 快捷键

    2023年04月08日
    浏览(73)
  • 你所不知道的NVMe SSD固态硬盘读写速度及国货的惊喜--基于FPGA的速度测试

      在\\\"FPGA实现高带宽NVMe SSD读写\\\"帖子中介绍了项目背景及系统架构、FPGA实现NVMe读写的大致实现方法。项目中需要将图像传感器产生的高速数据流实时稳定的持续存储,即不仅要求较高的存储带宽,还同时需要该存储带宽保持始终稳定、持续。   在项目做系统设计的时候

    2024年02月06日
    浏览(61)
  • 2.如何选择go语言基础类型——Leetcode习题9

    目录 本篇前瞻 Leetcode习题9 题目描述 原题解析 代码编写 有符号整形 基本数据类型 整形 有符号整形 无符号整形 浮点型 布尔型 字符 本篇小结 下一篇预告 欢迎来go语言的基础篇,这里会帮你梳理一下go语言的基本类型,注意本篇有参考go圣经,如果你有完整学习的需求可以看

    2024年02月12日
    浏览(42)
  • 你所不了解的静态路由特点及配置分析

     许多读者朋友错误地认为静态路由很简单,就一个命令,没什么好学的。其实这是因为他们根本没有深入理解静态路由的工作原理,对于仅有一条静态路由配置命令中的各参数和选项的含义和使用方法也是一知半解,结果造成的是遇到一些静态路由故障时无法进行分析,而

    2024年02月06日
    浏览(34)
  • Go语言中的流程控制语句

    目录 流程控制语句 if语句 if···else语句 switch语句 for循环 break语句 continue语句 goto语句 在Go语言中,可以在if后面加上一段执行语句,执行语句也可以用作对if条件的判断。它的语法格式为: a赋值为condition()方法的结果,然后让a与nil进行判断,如果为true,那么会执行代码块中

    2024年02月03日
    浏览(40)
  • Go语言入门记录:从基础到变量、函数、控制语句、包引用、interface、panic、go协程、Channel、sync下的waitGroup和Once等

    程序入口文件的包名必须是main,但主程序文件所在文件夹名称不必须是 main ,即我们下图 hello_world.go 在 main 中,所以感觉 package main 写顺理成章,但是如果我们把 main 目录名称改成随便的名字如 filename 也是可以运行的,所以迷思就在于写在文件开头的那个 package main 和 java

    2024年02月11日
    浏览(36)
  • PHP 课后习题解析与笔记——流程控制语句习题

    这篇文章记录一下帮助粉丝朋友解决的 PHP 课后习题,内容很基础,是关于 PHP 流程控制语句的使用练习,题目内容如下图的两题。这里我用 vscode 编译器和 Wampserver 完成这些题目。 php编写函数实现:输入一个整数,判断它能否被 3、5、7 整除,并输出以下信息之一: 能同时被

    2024年02月09日
    浏览(48)
  • Go:条件控制语句

    在 Go 语言中,主要的条件控制语句有 if-else 、 switch 和 select 。以下是对它们的简单介绍: if 语句用于根据条件执行不同的代码块。它的基本形式如下: condition 是一个布尔表达式,如果为真,将执行与 if 关联的代码块。 可以有零个或多个 else if 部分,每个 else if 部分都有一

    2024年02月05日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包