固定的输入格式(针对字符串型输入)为了让我记得更深刻<<<
恰逢遇到2023春招刷阿里、华为的机试题,采用ACM格式，自己构造输入输出，用golang敲了部分题后，做一部分的总结.
package main
import (
"bufio"
"os"
"fmt"
)
func main(){
input :=bufio.NewScanner(os.Stdin) // 多行输入
// 注意测试用例过长的话，要先指定bufio的bufer ，不然input.Scan会失败，读取空
// bufer :=make([]byte,2000*1024)
// input.Buffer(bufer,len(bufer))
for input.Scan(){ // 每调用一次Scan，从输入流中读取一行，相当于切换光标
str :=input.Text() // 获取这一行的输入
...
}
}
1.1 strings包
strings.IndexByte(str,byte) // 按照字符找位置
strings.Index(str,string) //按照字符串找位置
x :=[]rune(string) //将字符串转为切片
str :=string(x) //切片转为字符串
str :=fmt.Sprintf("%d个中国人吃%d个苹果",10,20) // 格式化字符串
1.2 strconv包
data,_ :=strconv.Atoi(str) //将字符串转为int类型
str,_ :=strconv.Itoa(int) //将整形转为string类型
str,_ :=strconv.ToLower(string) //全转为小写
//.ToUpper() //转为大写
// 解析字符串为整数，可以带符号 （string,进制,intX）
str,_ :=strconv.ParseInt("-2",10,64)
//解析字符串为浮点型 (string,floatX) X表示32或者64
str,_ :=strconv.ParseFloat("0.236",64)
1.3 sort包
sort.Ints([]int) // 直接从小到大排序整形切片
1.4 ascii码
48 表示 0
65 表示 A
97 表示 a
1.5 散列表
除留余数法
H(key) = key % mod 就是把可能是很大的key转化为 不超过mod的整数。
将一堆key映射成下标范围在[0,mod]中，mod通常取素数
但是会出现key1和key2映射在同一个下标的情况，也就是出现冲突
冲突解决办法：
1）线性探测法
H(key) 冲突，则检测H(key) +1是否被使用，线性加一，超过表长则循环，直到找到空位置，将该位置作为key在表[1,num]的下标索引
2）链地址法
每个H(key)都是对应一条单链表，产生冲突时直接在链表后面加上该节点。
如果key是一个字符串，要转化为唯一的整数，可以考虑进制转换
比如str []string是一个只包含字符串的数组，字符范围在A-Z内
假设转换str[1],将该字符串转换为整数
num :=0
for i:=0;i<len(str[1]);i++{
num = num*26 + (str[1][i] - 'A') //每个字符都转化为对应的26进制
}
最后 num就是对应的一个下标
1.6 二维切片初始化
dp :=make([][]int,len(grid)) //先给出切片的行数
for i:=0;i<len(grid);i++{
dp[i] =make([]int,0) // 初始化一维时无需用冒号，但要初始长度
for j:=0;j<len(grid[i]);j++{
dp[i] = append(dp[i],0)
}
}
1.7 切片指针
func add(data *[]int){
temp :=(*data)[0] //先取*号再取值
}
func sub(){
x :=make([]int,0)
add(&x) // 这里用地址符号传参
}
1.8 copy函数，复制切片
source :=[]int{1,2,3,4,5,6}
tar :=make([]int,2)
num :=copy(tar,source) //返回拷贝后切片的元素个数
2.1 非内嵌 结构体初始化
type data struct{
name string
age int
scores []int
}
func (h *data)update1(){
h.age =10
}
func (h data)update2(){
h.age = 10
}
func main(){
var temp1 data // 返回的是非引用
temp1.name = "xiaoming"
temp1.age = 10
temp1.scores = make([]int,10)
temp2 :=new(data) // 返回的是引用
temp2.age = 20
temp3 := &data{ //返回的引用，并且最后一个也是要逗号
name : "xiaohong",
age : 10,
}
// 对于方法update1 和update2, 三个变量都能调用
// 区别在于update1能使的变量本身生效
//update2的接受者是一个副本
}
2.2 内嵌结构体
package main
import "fmt"
type Book struct {
name string
title string
price int
}
type Library struct {
address string
newBook Book // 这是非指针类型，所以不能加地址符
books []Book
Book
}
func main() {
libr := &Library{
address: "中关村南大街5号",
newBook: Book{
name: "小王子",
title: "你好",
price: 10,
},
books: make([]Book, 0),
}
fmt.Println(libr)
// output : &{中关村南大街5号 {小王子 你好 10} []}
book1 := Book{
name: "大灰狼",
title: "小红帽",
price: 20,
}
libr.books = append(libr.books, book1)
fmt.Println(libr)
// output : &{中关村南大街5号 {小王子 你好 10} [{大灰狼 小红帽 20}]}
fmt.Println(book1)
// output: {大灰狼 小红帽 20}
// 注意 book1的输出没有加&，因为创建它没有用&，book1他就是一个变量
libr2 := Library{} //
libr2.price = 20 // 相当于直接继承Book
libr2.newBook.price = 30
// 上面两个都是price，第一个是匿名的Book类里面的price
// 第二个是newBook的成员price,输出顺序还和Library变量定义顺序有关
fmt.Println(libr2)
// output: { { 30} [] { 20}}
}
2.3 内嵌匿名结构体
// 基本用法
func temp(){
// 省略了type和名字关键字
book :=struct{ // 先定义匿名，注意不用逗号隔开
name string
price int
}{
name : "小王子",
price : 20,
}
// 这样就定义了一个匿名的结构体
fmt.Println(book.price)
}
// 解析JSON模板实例
package main
import (
"fmt"
"encoding/json"
)
type dataX struct{ //非匿名结构体
Code int //属性名称大小写不影响Unmarshal的解析
Msg string // Unmarshal会自动将它转为全部小写
}
func main(){
// 模拟一个json格式的字符串， ``是用来表示多行
jsonData := `{"code":20,"msg":"BIT"}`
//jsonDataX := "{\"code\":20,\"msg\":\"BIT\"}"
//jsonDataX 只是将"进行了转义，内容等价于jsonData
// 解析到非匿名结构体
temp :=&dataX{}
// 解析利用的反射机制
//Unmarshal第一个参数是[]byte类型的序列
//[]byte(str) 将字符串str转为byte类型的切片
//Unmarshal第二个参数必须是引用
if err :=json.Unmarshal([]byte(jsonData),temp);temp!=nil{
fmt.Println("解析出错")
}
fmt.Println(temp)
// output : &{20 BIT}
// 创建匿名结构体
temp2 :=&struct{ // 同样要加引用
Code int
Msg string
}{} //匿名结构体定义后一定要紧更花括号，用于赋值
if err :=json.Unmarshal([]byte(jsonData),temp2);err!=nil{
fmt.Println("解析出错")
}
fmt.Println(temp2)
// output : &{20 BIT}
var temp3 dataX
// 接下来使用时要在temp3前面加上&
if err :=json.Unmarshal([]byte(jsonData),&temp3 );err!=nil{
fmt.Println("解析出错")
}
fmt.Println(temp2)
// output : &{20 BIT}
}
2.4 json使用
package main
import (
"encoding/json"
"fmt"
)
// json 可选 `json:""`
type student struct {
Name string `json:"name"` // 标签为name小写
Age int `json:"age,omitempty"` // ,omitempty 字段为空时不解析,注意逗号要紧跟
Score int `json:"score"` // 标签为小写
Price int `json:"-"` // -不解析本字段
}
func main() {
stu1 := &student{
Name: "xiaohong",
Score: 90,
Price: 100,
}
stu2 := &student{
Name: "xiaog",
Age: 30,
Score: 90,
Price: 100,
}
res, _ := json.Marshal(stu1) // 返回的是[]byte
fmt.Println(string(res)) // 要转换为string
// 省略了Age
// output : {"name":"xiaohong","score":90}
res1, _ := json.Marshal(stu2)
fmt.Println(string(res1))
//output : {"name":"xiaog","age":30,"score":90}
// MarshalIndent(struct,preix,缩进)([]byte,err error)
res2, _ := json.MarshalIndent(stu1, "", " ") // 返回的是[]byte
fmt.Println(string(res2)) // 要转换为string
// output:
// {
// "name": "xiaohong", //这里的缩进是第三个参数
// "score": 90
// }
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）