acm-code/LC2/README.md

# Go 语言 ACM 格式输入输出教程

## 基础输入函数

使用 `fmt.Scan` 系列函数（不使用 bufio 缓冲区）：

| 函数 | 说明 |
|------|------|
| `fmt.Scan(&a)` | 读取一个值，以空格/换行分隔 |
| `fmt.Scanf("%d", &a)` | 带格式说明符读取 |
| `fmt.Scanln(&a)` | 读取一行，以换行结束 |
| `fmt.Sscan(str, &a)` | 从字符串读取 |

---

## 示例 1：单行读取两个整数

**输入：**
```
3 5
```

**代码：**
```go
package main

import "fmt"

func main() {
    var a, b int
    fmt.Scan(&a, &b)
    fmt.Println(a + b)
}
```

---

## 示例 2：先给 n，再读 n 个数

**输入：**
```
5
1 2 3 4 5
```

**代码：**
```go
package main

import "fmt"

func main() {
    var n int
    fmt.Scan(&n)

    arr := make([]int, n)
    for i := 0; i < n; i++ {
        fmt.Scan(&arr[i])
    }

    // 计算总和
    sum := 0
    for _, v := range arr {
        sum += v
    }
    fmt.Println(sum)
}
```

---

## 示例 3：多行输入，每行两个数

**输入：**
```
1 2
3 4
5 6
```

**代码：**
```go
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)
    }
}
```

---

## 示例 4：多组测试数据（EOF 结束）

**输入：**
```
3
1 2 3
2
4 5
```

**代码：**
```go
package main

import (
    "fmt"
    "io"
)

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

        sum := 0
        for i := 0; i < n; i++ {
            var x int
            fmt.Scan(&x)
            sum += x
        }
        fmt.Println(sum)
    }
}
```

---

## 示例 5：读取字符串

**输入：**
```
hello world
```

**代码：**
```go
package main

import "fmt"

func main() {
    var s string
    fmt.Scan(&s) // 只读到空格前
    fmt.Println(s) // 输出: hello

    // 读取整行
    fmt.Scanln() // 清除换行符
    var line string
    fmt.Scanln(&line)
    fmt.Println(line) // 输出: world
}
```

---

## 示例 6：特定结束符（输入 0 结束）

**输入：**
```
1
2
3
0
```

**代码：**
```go
package main

import "fmt"

func main() {
    for {
        var n int
        fmt.Scan(&n)
        if n == 0 {
            break
        }
        fmt.Println(n * 2)
    }
}
```

---

## 示例 7：读取不定长行（空格分隔）

**输入：**
```
1 2 3 4 5
```

**代码：**
```go
package main

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

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    line := scanner.Text()

    parts := strings.Fields(line)
    for _, s := range parts {
        n, _ := strconv.Atoi(s)
        fmt.Print(n, " ")
    }
    fmt.Println()
}
```

---

## 常用输出格式

```go
// 换行输出
fmt.Println(a, b)

// 空格分隔不换行
fmt.Print(a, " ", b)

// 格式化输出
fmt.Printf("%d %d\n", a, b)

// 拼接字符串输出
fmt.Println(strings.Join(strs, " "))
```

---

## 练习模板

```go
package main

import (
    "fmt"
    "io"
)

func main() {
    // 在这里写你的代码
    var n int
    if _, err := fmt.Scan(&n); err == io.EOF {
        return
    }

    // 处理逻辑
    fmt.Println(n)
}
```

---

## 注意事项

1. **输入输出效率**：纯 `fmt.Scan` 对于大量数据（>10^5）会较慢
2. **换行符处理**：`fmt.Scan` 会自动跳过空格和换行
3. **EOF 检测**：用 `io.EOF` 判断输入结束
4. **类型匹配**：确保变量类型与输入格式匹配