文章目录
- GoLang之控制台输入输出
- 1.源码
- 2.函数使用
- 2.1scan输入单个参数时，遇到回车会停止(多行)
- 2.2scan输入单个参数时，遇到空格会停止(多行)
- 2.3scan输入多个参数时，参数之间用回车(单行)
- 2.4scan输入多个参数时，参数之间用回车(多行)
- 2.5scan输入多个参数时，参数之间用空格(单行)
- 2.6scan输入多个参数时，参数之间用空格(多行)
- 2.7scanln输入单个参数时，遇到回车会停止(多行)
- 2.8scanln输入单个参数时，遇到空格会停止(多行)
- 2.9scanln输入多个参数时，参数之间不能用回车(单行)
- 2.10scanln输入多个参数时，参数之间不能用回车(多行)
- 2.11scanln输入多个参数时，参数之间用空格(单行)
- 2.12scanln输入多个参数时，参数之间用空格(多行)
- 2.13expected integer
- 3.例题
- 4.每行输入两个int数字，无限输入行数
- 5.每行输入两个int数字，指定输入行数
- 6.每行为容量为2的数组赋值，无限输入行数
- 7.每行为指定容量的切片赋值，无限输入行数，有结束标志
- 8.每行为指定容量的切片赋值，无限输入行数，无结束标志，输入错误时候就结束
- 9.指定矩阵长宽，进行输入
- 10.每行数字数量不固定，且不知道数量
- 11.任意矩阵输入
GoLang之控制台输入输出
1.源码
1.1Scan
Scan从标准输入扫描文本，将成功读取的空白分隔的值保存进成功传递给本函数的参数。换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。
func Scan(a ...interface{}) (n int, err error)
1.2Scanf
Scan从标准输入扫描文本，将成功读取的空白分隔的值保存进成功传递给本函数的参数。换行视为空白。返回成功扫描的条目个数和遇到的任何错误。如果读取的条目比提供的参数少，会返回一个错误报告原因。
func Sscan(str string, a ...interface{}) (n int, err error)
1.3Scanln
Scanln类似Scan，但会在换行时才停止扫描。最后一个条目后必须有换行或者到达结束位置。
func Scanln(a ...interface{}) (n int, err error)
2.函数使用
2.1scan输入单个参数时，遇到回车会停止(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scan(&t1)
fmt.Scan(&t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.2scan输入单个参数时，遇到空格会停止(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scan(&t1)
fmt.Scan(&t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.3scan输入多个参数时，参数之间用回车(单行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scan(&t1, &t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.4scan输入多个参数时，参数之间用回车(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
var t3 int
var t4 int
fmt.Scan(&t1, &t2)
fmt.Scan(&t3, &t4)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
fmt.Println(t4)
}
2.5scan输入多个参数时，参数之间用空格(单行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scan(&t1, &t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.6scan输入多个参数时，参数之间用空格(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
var t3 int
var t4 int
fmt.Scan(&t1, &t2)
fmt.Scan(&t3, &t4)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
fmt.Println(t4)
}
2.7scanln输入单个参数时，遇到回车会停止(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scanln(&t1)
fmt.Scanln(&t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.8scanln输入单个参数时，遇到空格会停止(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scanln(&t1)
fmt.Scanln(&t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.9scanln输入多个参数时，参数之间不能用回车(单行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scanln(&t1, &t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.10scanln输入多个参数时，参数之间不能用回车(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
var t3 int
var t4 int
fmt.Scanln(&t1, &t2)
fmt.Scanln(&t1, &t2)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
fmt.Println(t4)
}
2.11scanln输入多个参数时，参数之间用空格(单行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
fmt.Scanln(&t1, &t2)
fmt.Println(t1)
fmt.Println(t2)
}
2.12scanln输入多个参数时，参数之间用空格(多行)
package main
import (
"fmt"
)
func main() {
var t1 int
var t2 int
var t3 int
var t4 int
fmt.Scanln(&t1, &t2)
fmt.Scanln(&t3, &t4)
fmt.Println(t1)
fmt.Println(t2)
fmt.Println(t3)
fmt.Println(t4)
}
2.13expected integer
package main
import (
"fmt"
)
func main() {
var t int
n, err := fmt.Scan(&t)
fmt.Println(n)
fmt.Println(err)
}
3.例题
package main
import (
"fmt"
"io"
"math"
)
func main() {
n := 0
m := 0
for {
_, err := fmt.Scanf("%d %d", &n, &m)
if err != nil {
if err == io.EOF {
break
}
} else {
fmt.Printf("%.2f\n", Sum(n, m))
}
}
}
func Sum(n, m int) float64 {
var sum float64
var tmp float64
tmp = float64(n)
i := 1
for i <= m {
sum = sum + tmp
i++
tmp = math.Sqrt(tmp)
}
return sum
}
package main
import (
"fmt"
"io"
"math"
)
func main() {
n := 0
m := 0
for {
_, err := fmt.Scanf("%d%d", &n, &m)
if err != nil {
if err == io.EOF {
break
}
} else {
fmt.Printf("%.2f\n", Sum(n, m))
}
}
}
func Sum(n, m int) float64 {
var sum float64
var tmp float64
tmp = float64(n)
i := 1
for i <= m {
sum = sum + tmp
i++
tmp = math.Sqrt(tmp)
}
return sum
}
4.每行输入两个int数字，无限输入行数
需要注意的是这里的%d与%d之间有没有空格都无所谓，我们在控制台输入的时候两个数字之间都必须得有空格分隔，然后按会回车后便会输出答案
package main
import "fmt"
import "io"
func main() {
a := 0
b := 0
for {
_, err := fmt.Scanf("%d%d", &a, &b)
if err != nil {
if err == io.EOF {
break
}
} else {
fmt.Printf("%d\n", a+b)
}
}
}
package main
import "fmt"
import "io"
func main() {
a := 0
b := 0
for {
_, err := fmt.Scanf("%d %d", &a, &b)
if err != nil {
if err == io.EOF {
break
}
} else {
fmt.Printf("%d\n", a+b)
}
}
}
5.每行输入两个int数字，指定输入行数
题目：
1.输入描述:
输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 1000)2.输出描述:
输出a+b的结果
3.输入输出例子:
2
1 5
6
10 20
30
…
package main
import(
"fmt"
)
func main(){
var t,a,b int
fmt.Scanln(&t)
for i:=0;i<t;i++{
fmt.Scanln(&a,&b)
fmt.Println(a+b)
}
}
6.每行为容量为2的数组赋值，无限输入行数
package main
import (
"fmt"
)
func main() {
a := [2]int{}
for {
var sum int
for i := 0; i < 2; i++ {
fmt.Scan(&a[i])
}
for i := 0; i < 2; i++ {
sum += a[i]
}
fmt.Println(sum)
}
}
package main
import (
"fmt"
)
func main() {
for i := 0; i < 5; i++ {
var sum int
sum = sum + i
fmt.Println(sum)
}
/*
输出：
0
1
2
3
4
*/
}
7.每行为指定容量的切片赋值，无限输入行数，有结束标志
1.输入描述:
输入数据包括多组。
每组数据一行
n指定切片的容量
n为0的时候结束输入
求和n个正整数。
2.输出描述:
每组数据输出求和的结果
3.输入例子1:
4
1 2 3 4
10
5
1 2 3 4 5
15
0
结束
package main
import (
"fmt"
)
func main() {
var t int
for {
var sum int
fmt.Scan(&t)
if t == 0 {
break
} else {
a := make([]int, t)
for i := 0; i < t; i++ {
fmt.Scan(&a[i])
}
for i := 0; i < t; i++ {
sum += a[i]
}
}
fmt.Println(sum)
}
}
8.每行为指定容量的切片赋值，无限输入行数，无结束标志，输入错误时候就结束
需要注意的是，对于fmt.Scan(&t)来说只有输入为错误的时候才会分会字节数为0，当我们一直按回车的时候是不会返回字节数为0的
package main
import (
"fmt"
)
func main() {
var t int
for {
var sum int
n,_ := fmt.Scan(&t)
if n == 0 {
break
} else {
a := make([]int, t)
for i := 0; i < t; i++ {
fmt.Scan(&a[i])
}
for i := 0; i < t; i++ {
sum += a[i]
}
}
fmt.Println(sum)
}
}
9.指定矩阵长宽，进行输入
package main
import (
"fmt"
)
func main() {
var m, n int
fmt.Scanln(&m, &n)
res := make([][]int, m)
for i := range res {
res[i] = make([]int, n)
}
for i := 0; i < m; i++ {
for j := 0; j < n; j++ {
fmt.Scan(&res[i][j])
}
}
fmt.Println(res)
}
10.每行数字数量不固定，且不知道数量
package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
inputs := bufio.NewScanner(os.Stdin)
for inputs.Scan() { //每次读入一行
data := strings.Split(inputs.Text(), " ") //通过空格将他们分割，并存入一个字符串切片
var sum int
for i := range data {
val, _ := strconv.Atoi(data[i]) //将字符串转换为int
sum += val
}
fmt.Println(sum)
}
}
11.任意矩阵输入
package main
import (
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
func main() {
input := bufio.NewScanner(os.Stdin)
input.Scan() //读取一行内容
m, _ := strconv.Atoi(strings.Split(input.Text(), " ")[0])
n, _ := strconv.Atoi(strings.Split(input.Text(), " ")[1])
res := make([][]int, m)
for i := range res {
res[i] = make([]int, n)
}
for i := 0; i < m; i++ {
input.Scan() //读取一行内容
for j := 0; j < n; j++ {
res[i][j], _ = strconv.Atoi(strings.Split(input.Text(), " ")[j])
}
}
}
