用Golang刷ACM格式的OJ 笔记

用Golang刷ACM格式的OJ 笔记,第1张

为了让我记得更深刻<<<
恰逢遇到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
	// }

}


欢迎分享,转载请注明来源:内存溢出

原文地址: https://outofmemory.cn/langs/996362.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-05-21
下一篇 2022-05-21

发表评论

登录后才能评论

评论列表(0条)

保存