Go语言|【Golang】做算法题可能会用到的知识算法|开发语言|golang

文章目录

从控制台输入
- Reader
- Scanner
数据类型
- 通过字符串加下标的方式获取字符
- 通过 for range 字符串的方式获取字符
- 字符串与 []byte 互相转化
- byte 和 rune 的不同
- 浮点型和整型相互转换
存储
- 缓冲区
字符串
- 字节数组截取
- 由字符串转化为数字
- 分割
映射
- 检查键是否在映射中
切片
- 声明方式
排序
- 递增顺序
- 递减顺序

从控制台输入 Reader 读取一行字符串。

func main() { reader := bufio.NewReader(os.Stdin) line, _ := reader.ReadString('\n') l := len(line) fmt.Println(l) fmt.Println("回车", line[l-2]) fmt.Println("换行", line[l-1]) }

【Go语言|【Golang】做算法题可能会用到的知识】ReadString会不断读取，直到遇到第一个分隔符，这时ReadString把已读取的数据和分隔符以字符串的方式进行返回。
值得注意的是，当分隔符为\n（换行）时，ReadString会多读取一个\r（回车）。
读取一行字节数组。

func main() { reader := bufio.NewReader(os.Stdin) line, _ := reader.ReadBytes('\n') l := len(line) fmt.Println(l) fmt.Println("回车", line[l-2]) fmt.Println("换行", line[l-1]) }

Scanner 读取一行字符串。

func main() { scanner := bufio.NewScanner(os.Stdin) scanner.Scan() data := scanner.Text() fmt.Println(len(data)) fmt.Println(data) }

读取一行字节数组。

func main() { scanner := bufio.NewScanner(os.Stdin) scanner.Scan() data := scanner.Bytes() fmt.Println(len(data)) fmt.Println(data) }

相较于Reader，Scanner并不会把多余的回车符和换行符读取到。
不断地读取，直到读完所有的输入。

func main() { scanner := bufio.NewScanner(os.Stdin) for scanner.Scan() { fmt.Println(scanner.Text()) } }

数据类型通过字符串加下标的方式获取字符

package mainimport "fmt"func main() { str := "hello world" fmt.Printf("%T\n", str[0]) }

数据类型为uint8，也就是byte。
通过 for range 字符串的方式获取字符

func main() { str := "hello world" for i, c := range str { fmt.Printf("%T\n", c) if i == 0 { break } } }

数据类型为int32，也就是rune。
字符串与 []byte 互相转化

func main() { str := "hello world" data := []byte(str) fmt.Println(data) str = string(data) fmt.Println(str) str = string(data[:5]) fmt.Println(str) }

byte 和 rune 的不同

func main() { str := "hello world" data1 := []byte(str) fmt.Printf("%T\n", data1[len(data1)-1]) data2 := []rune(str) fmt.Printf("%T\n", data2[len(data2)-1]) }

byte本质上是uint8，而rune本质上是int32，当字符串中有中文时，rune会完整地保留中文。
浮点型和整型相互转换

func main() { var f = 5.5 fmt.Println(int(f)) }

由浮点型到整型，会保留浮点数的整数部分。
存储缓冲区

func main() { var buf bytes.Buffer buf.WriteString("hello") buf.WriteByte(' ') buf.WriteString("world") str := buf.String() fmt.Println(str) }

字符串字节数组截取

func main() { str := "hello world" data := []byte(str) fmt.Println(data[0:1]) }

输出的结果只有一个字符，说明截取的区间是半闭半开的。
由字符串转化为数字

func main() { str := "100" num, _ := strconv.Atoi(str) fmt.Println(num) str = strconv.Itoa(num) fmt.Println(str) }

分割

func main() { str := "hello world" arr :=strings.Split(str, " ") fmt.Println(arr[1]) }

映射检查键是否在映射中

func main() { m := make(map[int]int) m[0] = 1 if _, ok := m[1]; !ok { fmt.Println("hello world") } }

切片声明方式

package mainimport "fmt"func main() { var arr1 []int fmt.Println(arr1) arr2 := make([]int, 5) fmt.Println(arr2) }

从打印结果可以看出，在第二个切片中，已经完成了对元素的初始化。
排序递增顺序

func main() { arr := []int{4,5,6,1,2,3,0} sort.Ints(arr) fmt.Println(arr) strArr := []string{"hello", "world", "a", "b", "c"} sort.Strings(strArr) fmt.Println(strArr) }

递减顺序

func main() { arr := []int{4,5,6,1,2,3,0} sort.Sort(sort.Reverse(sort.IntSlice(arr))) fmt.Println(arr) strArr := []string{"hello", "world", "a", "b", "c"} sort.Sort(sort.Reverse(sort.StringSlice(strArr))) fmt.Println(strArr) }