Golang standard input/output processing

场景1：多行数据(不知道有几行)，每行固定个数，空格隔开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import (
    "fmt"
    "io"
)

func main() {
    var a, b int
    for {
        _, err := fmt.Scan(&a, &b)
        if err == io.EOF {
            break
        }
        fmt.Println(a + b)
    }
}

场景2：多行数据，第一行只有一个数字n，表示后面的行数，其他每行固定个数

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
    var n, a, b int
    fmt.Scan(&n)
    for i := 0; i < n; i++ {
        fmt.Scan(&a, &b)
        fmt.Println(a + b)
    }
}

场景3：输入数据有多行，每行固定个数，读取到特殊数据(如0,0)时停止

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func main() {
    var a, b int
    for {
        fmt.Scan(&a, &b)
        if a == 0 && b == 0 {
            break
        }
        fmt.Println(a + b)
    }
}

场景4：输入数据有多行，每行第一个数字指定当前行数据个数，读取到特殊数据时停止

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
    var n, a int
    for {
        fmt.Scan(&n)
        if n == 0 {
            break
        }
        sum := 0
        for i := 0; i < n; i++ {
            fmt.Scan(&a)
            sum += a
        }
        fmt.Println(sum)
    }
}

场景5：

输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来是n个正整数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func main() {
    var t, n, a int
    fmt.Scan(&t)
    for i := 0; i < t; i++ {
        fmt.Scan(&n)
        sum := 0
        for i := 0; i < n; i++ {
            fmt.Scan(&a)
            sum += a
        }
        fmt.Println(sum)
    }
}

场景6：

输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数。
不知道总共有多少行数据。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
    "fmt"
    "io"
)

func main() {
    var n, a int
    for {
        _, err := fmt.Scan(&n)
        if err == io.EOF {
            break
        }
        sum := 0
        for i := 0; i < n; i++ {
            fmt.Scan(&a)
            sum += a
        }
        fmt.Println(sum)
    }
}

场景7：

输入数据有多组, 每行表示一组输入数据。

每行不定有n个整数，空格隔开。(1 <= n <= 100)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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)
    }
}

场景8:

输入有两行，第一行n

第二行是n个字符串，字符串之间用空格隔开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import(
    "fmt"
    "os"
    "bufio"
    "sort"
    "strings"
)

func main(){
    in := bufio.NewScanner(os.Stdin)
    in.Scan()
    for in.Scan(){
        str := in.Text()
        s := strings.Split(str, " ")
        sort.Strings(s)  //排序
        fmt.Println(strings.Join(s," "))  //将切片连接成字符串
    }
}

场景9：

多个测试用例，每个测试用例一行。

每行通过空格隔开，有n个字符，n＜100

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import(
    "fmt"
    "bufio"
    "os"
    "strings"
    "sort"
)

func main() {
    in := bufio.NewScanner(os.Stdin)
    for in.Scan() {
        strs := strings.Split(in.Text(), " ")
        sort.Strings(strs)
        fmt.Println(strings.Join(strs, " "))
    }
}

场景10：与场景9基本相同，只是分隔符由空格换成逗号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import(
    "fmt"
    "bufio"
    "os"
    "strings"
    "sort"
)

func main() {
    in := bufio.NewScanner(os.Stdin)
    for in.Scan() {
        strs := strings.Split(in.Text(), ",")
        sort.Strings(strs)
        fmt.Println(strings.Join(strs, ","))
    }
}