Go ACM 模式下处理输入输出

牛客 - OJ在线编程常见输入输出练习

获取输入

  • 以空格为分隔符获取输入（换行视为空格）
    1. 从任意输入流(os.Stdin, …)中获取输入: fmt.Fscan(io.Reader, ...interface{})
    2. 从标准输入流中获取输入：fmt.Scan(...interface{})
    3. 从字符串中获取输入：fmt.Sscan(string, ...interface{})
  • 以换行为分割符获取输入（遇到换行才会停止扫描）
    1. 从任意输入流(os.Stdin, …)中获取输入: fmt.Fscanln(io.Reader, ...interface{})
    2. 从标准输入流中获取输入：fmt.Scanln(...interface{})
    3. 从字符串中获取输入：fmt.Sscanln(string, ...interface{})
  • 以特定格式获取输入（接受string类型的格式字符串）
    1. 从任意输入流(os.Stdin, …)中获取输入: fmt.Fscanf(io.Reader, string, ...interface{})
    2. 从标准输入流中获取输入：fmt.Scanf(string, ...interface{})
    3. 从字符串中获取输入：fmt.Sscanf(string, string, ...interface{})
  • 使用 bufio 以字符串或[]byte 形式读入一行再进行处理 ```go // 可能需要用到的包 import ( “fmt” “os” “bufio” “strings” “strconv” )

input := bufio.NewScanner(os.Stdin) //创建并返回一个从os.Stdin读取数据的Scanner for input.Scan(){ // Scan方法获取当前位置的token（该token可以通过Bytes或Text方法获得）， // 并让Scanner的扫描位置移动到下一个token。 // 当扫描因为抵达输入流结尾或者遇到错误而停止时，本方法会返回false bufs := strings.Split(input.Text(), “ “) //分割字符串 }

  1. <a name="b52712aa"></a>
  2. ### 格式字符串
  4. 1.  通用 
  5. ```go
  6. %v    值的默认格式表示
  7. %+v    类似%v，但输出结构体时会添加字段名
  8. %#v    值的Go语法表示
  9. %T    值的类型的Go语法表示
  10. %%    百分号

  1. 布尔值 

    1. %t    单词true或false

  2. 整数 

    1. %b    表示为二进制
    2. %c    该值对应的unicode码值
    3. %d    表示为十进制
    4. %o    表示为八进制
    5. %q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
    6. %x    表示为十六进制，使用a-f
    7. %X    表示为十六进制，使用A-F
    8. %U    表示为Unicode格式：U+1234，等价于"U+%04X"

  3. 浮点数和复数 ```go %b 无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat %e 科学计数法，如-1234.456e+78 %E 科学计数法，如-1234.456E+78 %f 有小数部分但无指数部分，如123.456 %F 等价于%f %g 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出） %G 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

// 宽度和精度 %f: 默认宽度，默认精度 %9f 宽度9，默认精度 %.2f 默认宽度，精度2 %9.2f 宽度9，精度2 %9.f 宽度9，精度0

  2. 5.  字符串和[]byte 
  3. ```go
  4. %s    直接输出字符串或者[]byte
  5. %q    该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
  6. %x    每个字节用两字符十六进制数表示（使用a-f）
  7. %X    每个字节用两字符十六进制数表示（使用A-F）
  1. 指针 
    1. %p    表示为十六进制，并加上前导的0x

    常量定义

    ```go import { “fmt” “math” }

// 使用移位方式定义常量 // 无符号整型 const UINTMIN uint = 0 const UINTMAX uint = ^uint(0) //全为1

// 有符号整型 const INTMAX int = int(^uint(0)>>1) //首位为0，其余为1 const INTMIN int = ^INTMIN // 首位为1，其余为0

// 使用 math 包定义常量 fmt.Printf(“float64的最大值是:%.f\n”, math.MaxFloat64) fmt.Printf(“float64的最小值是:%.f\n”, math.SmallestNonzeroFloat64) fmt.Printf(“float32的最大值是:%.f\n”, math.MaxFloat32) fmt.Printf(“float32的最小值是:%.f\n”, math.SmallestNonzeroFloat32) fmt.Printf(“Int8的最大值是:%d\n”, math.MaxInt8) fmt.Printf(“Int8的最小值是:%d\n”, math.MinInt8) fmt.Printf(“Uint8的最大值是:%d\n”, math.MaxUint8) fmt.Printf(“Int16的最大值是:%d\n”, math.MaxInt16) fmt.Printf(“Int16的最小值是:%d\n”, math.MinInt16) fmt.Printf(“Uint16的最大值是:%d\n”, math.MaxUint16) fmt.Printf(“Int32的最大值是:%d\n”, math.MaxInt32) fmt.Printf(“Int32的最小值是:%d\n”, math.MinInt32) fmt.Printf(“Uint32的最大值是:%d\n”, math.MaxUint32) fmt.Printf(“Int64的最大值是:%d\n”, math.MaxInt64) fmt.Printf(“Int64的最小值是:%d\n”, math.MinInt64) fmt.Println(“Uint64的最大值是:”, math.MaxUint64) fmt.Printf(“圆周率默认为:%.200f\n”, math.Pi)

  1. <a name="7142ed02"></a>
  2. ## 如何给递归函数debug
  3. ```go
  4. // 全局变量，记录递归函数的递归层数
  5. var count int = 0
  7. // 输入n，打印n个tab缩进
  8. func printIndent(n int){
  9.     for i := 0; i < n; i++{
  10.         fmt.Print("    ")
  11.     }
  12. }
  14. // 利用回溯的思想
  15. // 在递归函数的开头增加缩进并打印，打印关键变量
  16. // 在return语句之前减少缩进并打印，打印返回值
  17. func dp(i, j int){
  18.     if j == len(nums){
  19.         return 0
  20.     }
  21.     // 打印缩进和变量
  22.     printIndent(count)
  23.     fmt.Println(i, j)
  24.     count++
  26.     res := dp(i+1, j+1)
  28.     // 打印返回值
  29.     count--
  30.     printIndent(count)
  31.     fmt.Println(i, j)
  33.     return res
  34. }