华为AI机试ACM模式输入输出大全

ACM模式输入输出完全指南

一、ACM模式基础知识

什么是ACM模式？

  • 需要手动处理标准输入输出（stdin/stdout）
  • 不同于OJ模式（函数签名给定）
  • 华为机试使用此模式

Python输入输出函数

1
2
3
4
5
6
7
8
9
# 输入
input()          # 读取一行，返回字符串（自动去除换行符）
sys.stdin.readline()  # 读取一行（保留换行符，需strip()）
sys.stdin.readlines() # 读取所有行

# 输出
print()          # 输出并换行
print(x, end='') # 输出不换行
sys.stdout.write() # 直接写入（需手动添加\n）

二、常见输入格式模板⭐⭐⭐⭐⭐

格式总览表

格式类型 输入示例 关键代码 难度
单个整数 5 n = int(input()) ⭐
多个整数 1 2 3 nums = list(map(int, input().split())) ⭐
已知行数 3 + 3行数据 for _ in range(n): ... ⭐⭐
未知行数(EOF) 多行数据 for line in sys.stdin: ... ⭐⭐⭐
矩阵输入 n m + n行数据 matrix = [list(map(int, input().split())) for _ in range(n)] ⭐⭐
字符串处理 hello world s = input().strip() ⭐
逗号分隔 1,2,3 nums = list(map(int, input().split(','))) ⭐⭐
混合类型 Alice 25 3.5 name, age, score = line[0], int(line[1]), float(line[2]) ⭐⭐⭐
多组测试 T + T组数据 for _ in range(T): ... ⭐⭐
JSON格式 {"key": "value"} import json; data = json.loads(input()) ⭐⭐⭐⭐
嵌套列表 [[1,2],[3,4]] import ast; data = ast.literal_eval(input()) ⭐⭐⭐⭐
不规则输入 混合格式 需要灵活解析 ⭐⭐⭐⭐⭐

1. 单行单个整数

输入格式：

1
5

代码：

1
2
n = int(input())
print(n)

逐行解释：

  • input() - 从标准输入读取一行字符串，自动去除末尾的换行符
  • int() - 将字符串转换为整数类型
  • print() - 输出结果到标准输出

实战例题1：判断奇偶

1
2
3
4
5
6
7
8
9
10
题目：输入一个整数，判断是奇数还是偶数
输入：7
输出：奇数

代码：
n = int(input())
if n % 2 == 0:
    print("偶数")
else:
    print("奇数")

实战例题2：计算平方

1
2
3
4
5
6
7
8
9
题目：输入一个整数n，输出n的平方
输入：5
输出：25

代码：
n = int(input())
result = n * n
print(result)
# 或者使用 print(n ** 2)

实战例题3：阶乘计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
题目：输入一个整数n（0 <= n <= 10），输出n的阶乘
输入：5
输出：120

代码：
import math
n = int(input())
print(math.factorial(n))

# 或手动实现
n = int(input())
result = 1
for i in range(1, n + 1):
    result *= i
print(result)

常见错误示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 错误1：忘记类型转换
n = input()  # n是字符串"5"，不是整数5
print(n + 1)  # TypeError: can only concatenate str to str

# 正确：
n = int(input())
print(n + 1)  # 6

# 错误2：输入为空或非数字
n = int(input())  # 如果输入为空，会报 ValueError

# 正确（需要容错）：
try:
    n = int(input())
except ValueError:
    n = 0  # 默认值

调试技巧：

1
2
3
4
5
6
7
8
9
# 技巧1：查看输入的原始内容
raw_input = input()
print(f"原始输入: '{raw_input}'", file=sys.stderr)  # 调试信息输出到stderr
print(f"长度: {len(raw_input)}", file=sys.stderr)
n = int(raw_input)

# 技巧2：添加边界检查
n = int(input())
assert 0 <= n <= 100, f"输入超出范围: {n}"

2. 单行多个整数（空格分隔）

输入格式：

1
1 2 3 4 5

代码模板1（列表）：

1
2
nums = list(map(int, input().split()))
print(nums)  # [1, 2, 3, 4, 5]

逐行解释：

  • input() - 读取一行：”1 2 3 4 5”
  • .split() - 按空格分割，得到 [“1”, “2”, “3”, “4”, “5”]
  • map(int, ...) - 将每个字符串元素转换为整数
  • list() - 将map对象转换为列表

代码模板2（多个变量）：

1
2
a, b, c = map(int, input().split())
print(a, b, c)  # 1 2 3

注意： 变量数量必须与输入数量一致，否则会报 ValueError

实战例题1：两数之和

1
2
3
4
5
6
7
题目：输入两个整数，输出它们的和
输入：10 20
输出：30

代码：
a, b = map(int, input().split())
print(a + b)

实战例题2：数组排序

1
2
3
4
5
6
7
8
题目：输入一组整数，按升序输出
输入：5 2 8 1 9
输出：1 2 5 8 9

代码：
nums = list(map(int, input().split()))
nums.sort()
print(' '.join(map(str, nums)))

实战例题3：找最大值和最小值

1
2
3
4
5
6
7
题目：输入一组整数，输出最大值和最小值
输入：3 7 2 9 1
输出：9 1

代码：
nums = list(map(int, input().split()))
print(max(nums), min(nums))

实战例题4：计算平均值

1
2
3
4
5
6
7
8
题目：输入一组整数，输出平均值（保留2位小数）
输入：10 20 30 40 50
输出：30.00

代码：
nums = list(map(int, input().split()))
avg = sum(nums) / len(nums)
print(f"{avg:.2f}")

常见错误示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 错误1：变量数量不匹配
a, b = map(int, input().split())  # 输入"1 2 3"
# ValueError: too many values to unpack (expected 2)

# 正确：使用列表接收
nums = list(map(int, input().split()))  # 可以接收任意数量

# 错误2：忘记 list()
nums = map(int, input().split())  # nums是map对象，不是列表
print(nums[0])  # TypeError: 'map' object is not subscriptable

# 正确：
nums = list(map(int, input().split()))
print(nums[0])

# 错误3：输入包含多余空格
# 输入："1  2  3"（多个空格）
nums = list(map(int, input().split()))  # 没问题，split()会自动处理多个空格
# 但如果使用 split(' ')，会产生空字符串
nums = list(map(int, input().split(' ')))  # 错误！会有空字符串

# 正确：
nums = list(map(int, input().split()))  # 不指定分隔符，自动处理连续空格

# 错误4：输入为空
nums = list(map(int, input().split()))  # 输入为空行，nums = []
result = nums[0]  # IndexError: list index out of range

# 正确（加边界检查）：
nums = list(map(int, input().split()))
if len(nums) > 0:
    result = nums[0]
else:
    result = 0  # 默认值

调试技巧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 技巧1：查看中间步骤
line = input()
print(f"原始输入: '{line}'", file=sys.stderr)
tokens = line.split()
print(f"分割后: {tokens}", file=sys.stderr)
nums = list(map(int, tokens))
print(f"转换后: {nums}", file=sys.stderr)

# 技巧2：处理可能的异常输入
try:
    nums = list(map(int, input().split()))
except ValueError as e:
    print(f"输入格式错误: {e}", file=sys.stderr)
    nums = []

3. 多行输入（已知行数）

输入格式：

1
2
3
4
3
10 20
30 40
50 60

代码：

1
2
3
4
5
6
7
8
n = int(input())  # 读取行数
data = []
for _ in range(n):
    row = list(map(int, input().split()))
    data.append(row)

print(data)
# [[10, 20], [30, 40], [50, 60]]

逐行解释：

  • 第1行：读取行数n
  • 第2-3行：初始化空列表，用for循环读取n行
  • 第4行：每行读取并转换为整数列表
  • 第5行：将当前行添加到data中

列表推导式写法（更简洁）：

1
2
n = int(input())
data = [list(map(int, input().split())) for _ in range(n)]

实战例题1：计算每行的和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
题目：给定n行数据，输出每行元素的和
输入：
3
1 2 3
4 5
6 7 8 9
输出：
6
9
30

代码：
n = int(input())
for _ in range(n):
    nums = list(map(int, input().split()))
    print(sum(nums))

实战例题2：找出所有偶数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
题目：给定n行数据，输出所有偶数，每个一行
输入：
3
1 2 3 4
5 6 7
8 9 10
输出：
2
4
6
8
10

代码：
n = int(input())
for _ in range(n):
    nums = list(map(int, input().split()))
    for num in nums:
        if num % 2 == 0:
            print(num)

实战例题3：矩阵的行最大值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
题目：给定n行数据，输出每行的最大值
输入：
3
5 2 8
1 9 3
7 4 6
输出：
8
9
7

代码：
n = int(input())
for _ in range(n):
    nums = list(map(int, input().split()))
    print(max(nums))

实战例题4：学生成绩统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
题目：输入n个学生的成绩（每行：姓名 分数1 分数2 分数3），输出每个学生的平均分
输入：
3
Alice 85 90 88
Bob 78 82 80
Charlie 92 95 90
输出：
Alice 87.67
Bob 80.00
Charlie 92.33

代码：
n = int(input())
for _ in range(n):
    parts = input().split()
    name = parts[0]
    scores = list(map(int, parts[1:]))
    avg = sum(scores) / len(scores)
    print(f"{name} {avg:.2f}")

常见错误示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 错误1：循环次数错误
n = int(input())
for i in range(n + 1):  # 错误！会多读一行
    row = list(map(int, input().split()))

# 正确：
for i in range(n):  # 读取n行

# 错误2：忘记每次都要读取
n = int(input())
data = []
for _ in range(n):
    data.append([1, 2, 3])  # 错误！没有实际读取输入

# 正确：
for _ in range(n):
    row = list(map(int, input().split()))
    data.append(row)

# 错误3：在循环外读取
n = int(input())
row = list(map(int, input().split()))  # 只读取了第一行
for _ in range(n):
    data.append(row)  # 错误！每次都添加同一行

# 正确：
for _ in range(n):
    row = list(map(int, input().split()))  # 在循环内读取
    data.append(row)

# 错误4：行数为0的情况
n = int(input())  # n = 0
data = []
for _ in range(n):  # 不会执行
    row = list(map(int, input().split()))
    data.append(row)
# data = []，需要处理空数据情况

# 正确（加检查）：
n = int(input())
if n == 0:
    print("无数据")
else:
    for _ in range(n):
        row = list(map(int, input().split()))
        # 处理数据

调试技巧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import sys

# 技巧1：显示当前读到第几行
n = int(input())
for i in range(n):
    print(f"读取第{i+1}行", file=sys.stderr)
    row = list(map(int, input().split()))
    print(f"数据: {row}", file=sys.stderr)

# 技巧2：验证读取的行数
n = int(input())
data = []
for _ in range(n):
    row = list(map(int, input().split()))
    data.append(row)
assert len(data) == n, f"期望{n}行，实际读取{len(data)}行"

4. 多行输入（未知行数，读到EOF）

输入格式：

1
2
3
1 2
3 4
5 6

代码模板1（推荐）：

1
2
3
4
5
6
7
8
import sys

data = []
for line in sys.stdin:
    row = list(map(int, line.strip().split()))
    data.append(row)

print(data)

逐行解释：

  • sys.stdin - 标准输入流对象
  • for line in sys.stdin - 逐行迭代，读到EOF自动停止
  • line.strip() - 去除行尾的换行符 \n
  • .split() - 按空格分割

代码模板2（try-except）：

1
2
3
4
5
6
7
8
9
data = []
while True:
    try:
        row = list(map(int, input().split()))
        data.append(row)
    except EOFError:
        break

print(data)

代码模板3（一次性读取）：

1
2
3
4
5
import sys

lines = sys.stdin.readlines()
data = [list(map(int, line.strip().split())) for line in lines]
print(data)

三种方法对比：

方法 优点 缺点 适用场景
sys.stdin迭代 内存效率高，代码简洁 需要import 大数据量
try-except 不需要import sys 代码稍长 小数据量
readlines 一次性读取 内存占用大 需要预处理全部数据

实战例题1：求所有数的总和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
题目：读取所有输入的整数，输出总和
输入：
1 2 3
4 5
6 7 8 9
输出：
45

代码方法1（sys.stdin）：
import sys

total = 0
for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    total += sum(nums)
print(total)

代码方法2（try-except）：
total = 0
while True:
    try:
        nums = list(map(int, input().split()))
        total += sum(nums)
    except EOFError:
        break
print(total)

实战例题2：统计行数和总元素数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
题目：统计输入的行数和所有整数的个数
输入：
1 2 3
4 5
6
输出：
行数: 3
元素数: 6

代码：
import sys

line_count = 0
element_count = 0

for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    line_count += 1
    element_count += len(nums)

print(f"行数: {line_count}")
print(f"元素数: {element_count}")

实战例题3：过滤和转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
题目：读取所有数据，只保留偶数，并按升序输出
输入：
5 2 8 1
9 4 3
6 7
输出：
2 4 6 8

代码：
import sys

even_nums = []
for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    even_nums.extend([n for n in nums if n % 2 == 0])

even_nums.sort()
print(' '.join(map(str, even_nums)))

实战例题4：边读边处理（流式处理）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
题目：读取数据，每行输出该行的平均值（实时处理）
输入：
10 20 30
40 50
60
输出：
20.00
45.00
60.00

代码：
import sys

for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    avg = sum(nums) / len(nums)
    print(f"{avg:.2f}")

常见错误示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# 错误1：忘记 strip()
import sys
for line in sys.stdin:
    nums = list(map(int, line.split()))  # line可能包含 \n
# 大多数情况下没问题，但某些情况下会出错

# 正确：
for line in sys.stdin:
    nums = list(map(int, line.strip().split()))

# 错误2：sys.stdin在交互式环境中的问题
import sys
for line in sys.stdin:  # 交互式环境会一直等待输入
    pass
# 在IDE中可能需要手动发送EOF（Ctrl+D/Ctrl+Z）

# 正确（本地测试）：
import sys
# 方法1：重定向文件
sys.stdin = open('input.txt', 'r')
for line in sys.stdin:
    pass

# 方法2：使用try-except
while True:
    try:
        line = input()
    except EOFError:
        break

# 错误3：混用 input() 和 sys.stdin
n = int(input())  # 先用input读了一行
for line in sys.stdin:  # 再用sys.stdin，可能会跳过数据
    pass

# 正确：统一使用一种方式
import sys
n = int(sys.stdin.readline().strip())
for line in sys.stdin:
    pass

# 错误4：空行处理
import sys
for line in sys.stdin:
    if not line.strip():  # 跳过空行
        continue
    nums = list(map(int, line.strip().split()))

# 错误5：提前break
import sys
for line in sys.stdin:
    if line.strip() == "":
        break  # 遇到空行就停止，可能数据还没读完
    nums = list(map(int, line.strip().split()))

# 正确（如果确实需要遇到空行停止）：
import sys
for line in sys.stdin:
    if line.strip() == "":
        break
    nums = list(map(int, line.strip().split()))

调试技巧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import sys

# 技巧1：查看原始输入
for i, line in enumerate(sys.stdin, 1):
    print(f"第{i}行原始: {repr(line)}", file=sys.stderr)
    line = line.strip()
    print(f"第{i}行处理后: {repr(line)}", file=sys.stderr)

# 技巧2：本地文件测试
if __name__ == "__main__":
    # 提交时注释掉这两行
    import sys
    sys.stdin = open('input.txt', 'r')
    
    for line in sys.stdin:
        nums = list(map(int, line.strip().split()))
        print(nums)

# 技巧3：模拟输入（单元测试）
def solve(input_data):
    """可测试的函数版本"""
    result = []
    for line in input_data:
        nums = list(map(int, line.strip().split()))
        result.append(sum(nums))
    return result

# 测试
test_input = ["1 2 3\n", "4 5\n", "6\n"]
print(solve(test_input))  # [6, 9, 6]

EOF输入的特殊情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 情况1：Windows下手动输入EOF
# 命令行输入完数据后，按 Ctrl+Z 然后 Enter

# 情况2：Linux/Mac下手动输入EOF
# 命令行输入完数据后，按 Ctrl+D

# 情况3：管道输入
# echo -e "1 2\n3 4" | python solution.py

# 情况4：文件重定向
# python solution.py < input.txt

# 情况5：在线OJ系统
# 自动发送EOF，无需手动操作

5. 矩阵输入（二维数组）

输入格式：

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

代码：

1
2
3
4
5
6
7
8
9
10
n, m = map(int, input().split())  # n行m列
matrix = []
for i in range(n):
    row = list(map(int, input().split()))
    matrix.append(row)

# 或使用列表推导式
matrix = [list(map(int, input().split())) for _ in range(n)]

print(matrix)

6. 字符串输入

输入格式：

1
hello world

代码：

1
2
3
4
5
6
7
8
9
10
11
# 读取整行（包括空格）
line = input()
print(line)  # "hello world"

# 读取单词列表
words = input().split()
print(words)  # ["hello", "world"]

# 读取单个字符串（无空格）
s = input().strip()
print(s)

7. 逗号分隔输入

输入格式：

1
1,2,3,4,5

代码：

1
2
nums = list(map(int, input().split(',')))
print(nums)  # [1, 2, 3, 4, 5]

8. 混合类型输入

输入格式：

1
2
Alice 25 3.5
Bob 30 4.0

代码：

1
2
3
4
5
6
for _ in range(2):
    line = input().split()
    name = line[0]
    age = int(line[1])
    score = float(line[2])
    print(name, age, score)

9. 多组测试用例

输入格式：

1
2
3
4
5
2
3
1 2 3
5
4 5 6 7 8

代码：

1
2
3
4
5
6
7
T = int(input())  # 测试用例数量
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))
    # 处理当前测试用例
    result = sum(nums)
    print(result)

逐行解释：

  • 第1行：读取测试用例的总数T
  • 第2-7行：循环T次，每次处理一个完整的测试用例
  • 每个测试用例独立处理，输出各自的结果

实战例题1：多组a+b问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
题目：T组测试，每组两个数，输出它们的和
输入：
3
1 2
5 10
100 200
输出：
3
15
300

代码：
T = int(input())
for _ in range(T):
    a, b = map(int, input().split())
    print(a + b)

实战例题2：多组排序问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
题目：T组测试，每组先输入n，再输入n个数，输出排序后的结果
输入：
2
3
5 2 8
4
1 9 3 7
输出：
2 5 8
1 3 7 9

代码：
T = int(input())
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))
    nums.sort()
    print(' '.join(map(str, nums)))

实战例题3：多组矩阵问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
题目：T组测试，每组输入一个2x2矩阵，输出其行列式的值
输入：
2
1 2
3 4
5 6
7 8
输出：
-2
-2

代码：
T = int(input())
for _ in range(T):
    row1 = list(map(int, input().split()))
    row2 = list(map(int, input().split()))
    # 计算2x2行列式: ad - bc
    det = row1[0] * row2[1] - row1[1] * row2[0]
    print(det)

实战例题4：多组字符串问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
题目：T组测试，每组输入一个字符串，判断是否为回文
输入：
3
level
hello
racecar
输出：
Yes
No
Yes

代码：
T = int(input())
for _ in range(T):
    s = input().strip()
    if s == s[::-1]:
        print("Yes")
    else:
        print("No")

常见错误示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
# 错误1：忘记读取T
# 错误代码：
for _ in range(3):  # 硬编码测试用例数
    n = int(input())
    nums = list(map(int, input().split()))

# 正确代码：
T = int(input())  # 从输入读取
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))

# 错误2：循环内忘记读取所有数据
T = int(input())
for _ in range(T):
    n = int(input())
    # 忘记读取下一行数据
    # nums = list(map(int, input().split()))  # 这行被注释掉了
    print(n)  # 输出错误，数据错位

# 正确：确保每次循环读取完整数据
T = int(input())
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))  # 必须读取
    print(sum(nums))

# 错误3：提前退出循环
T = int(input())
for i in range(T):
    n = int(input())
    if n == 0:
        break  # 错误！会导致后续测试用例无法处理
    nums = list(map(int, input().split()))

# 正确：处理所有测试用例
T = int(input())
for i in range(T):
    n = int(input())
    if n == 0:
        print(0)  # 处理特殊情况但继续循环
        continue
    nums = list(map(int, input().split()))
    print(sum(nums))

# 错误4：测试用例之间有依赖
T = int(input())
result = 0  # 全局结果
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))
    result += sum(nums)  # 错误！累加了所有测试用例
print(result)  # 只输出一次

# 正确：每个测试用例独立
T = int(input())
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))
    result = sum(nums)  # 局部变量
    print(result)  # 每次输出

调试技巧：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import sys

# 技巧1：显示当前处理的测试用例编号
T = int(input())
for case_num in range(1, T + 1):
    print(f"处理测试用例 {case_num}", file=sys.stderr)
    n = int(input())
    nums = list(map(int, input().split()))
    result = sum(nums)
    print(result)

# 技巧2：验证每个测试用例的输入
T = int(input())
for _ in range(T):
    n = int(input())
    print(f"期望读取 {n} 个数", file=sys.stderr)
    nums = list(map(int, input().split()))
    print(f"实际读取 {len(nums)} 个数: {nums}", file=sys.stderr)
    assert len(nums) == n, "数量不匹配"
    print(sum(nums))

# 技巧3：使用函数封装单个测试用例的逻辑
def solve_one_case():
    """处理单个测试用例"""
    n = int(input())
    nums = list(map(int, input().split()))
    return sum(nums)

T = int(input())
for _ in range(T):
    result = solve_one_case()
    print(result)

10. JSON格式输入输出⭐⭐⭐⭐

输入格式：

1
{"name": "Alice", "age": 25, "scores": [85, 90, 88]}

基础代码：

1
2
3
4
5
6
7
8
9
import json

# 读取JSON字符串
json_str = input()
data = json.loads(json_str)

print(data["name"])    # Alice
print(data["age"])     # 25
print(data["scores"])  # [85, 90, 88]

实战例题1：学生信息处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目：输入学生信息JSON，输出平均分
输入：
{"name": "Bob", "scores": [78, 82, 85, 90]}
输出：
Bob 83.75

代码：
import json

data = json.loads(input())
name = data["name"]
scores = data["scores"]
avg = sum(scores) / len(scores)
print(f"{name} {avg:.2f}")

实战例题2：嵌套JSON处理

1
2
3
4
5
6
7
8
9
10
11
12
13
题目：输入包含学生列表的JSON，输出每个学生的总分
输入：
{"class": "A", "students": [{"name": "Alice", "score": 85}, {"name": "Bob", "score": 90}]}
输出：
Alice 85
Bob 90

代码：
import json

data = json.loads(input())
for student in data["students"]:
    print(f"{student['name']} {student['score']}")

实战例题3：多行JSON输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
题目：输入n行JSON，统计所有人的总分
输入：
3
{"name": "Alice", "score": 85}
{"name": "Bob", "score": 90}
{"name": "Charlie", "score": 88}
输出：
263

代码：
import json

n = int(input())
total = 0
for _ in range(n):
    data = json.loads(input())
    total += data["score"]
print(total)

JSON输出：

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

# 字典转JSON输出
data = {"name": "Alice", "age": 25, "scores": [85, 90, 88]}
print(json.dumps(data))
# 输出: {"name": "Alice", "age": 25, "scores": [85, 90, 88]}

# 格式化输出（缩进）
print(json.dumps(data, indent=2))
# 输出:
# {
#   "name": "Alice",
#   "age": 25,
#   "scores": [85, 90, 88]
# }

# 确保中文不被转义
data = {"姓名": "张三", "分数": 95}
print(json.dumps(data, ensure_ascii=False))
# 输出: {"姓名": "张三", "分数": 95}

常见错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 错误1：JSON格式不正确
json_str = "{'name': 'Alice'}"  # 单引号，不是标准JSON
data = json.loads(json_str)  # JSONDecodeError

# 正确：使用双引号
json_str = '{"name": "Alice"}'
data = json.loads(json_str)

# 错误2：访问不存在的键
data = {"name": "Alice"}
print(data["age"])  # KeyError

# 正确：使用get方法
print(data.get("age", 0))  # 返回默认值0

# 错误3：忘记导入json模块
data = json.loads(input())  # NameError: name 'json' is not defined

# 正确：
import json
data = json.loads(input())

11. 嵌套列表和复杂数据结构⭐⭐⭐⭐

输入格式1：字符串表示的列表

1
[[1,2,3],[4,5,6]]

代码：

1
2
3
4
5
import ast

list_str = input()
data = ast.literal_eval(list_str)
print(data)  # [[1, 2, 3], [4, 5, 6]]

实战例题1：嵌套列表求和

1
2
3
4
5
6
7
8
9
10
11
12
题目：输入嵌套列表，输出所有元素的和
输入：
[[1,2],[3,4,5],[6]]
输出：
21

代码：
import ast

data = ast.literal_eval(input())
total = sum(sum(row) for row in data)
print(total)

实战例题2：不规则矩阵的列数

1
2
3
4
5
6
7
8
9
10
11
12
题目：输入嵌套列表，输出每行的元素个数
输入：
[[1,2,3],[4,5],[6,7,8,9]]
输出：
3 2 4

代码：
import ast

data = ast.literal_eval(input())
lengths = [len(row) for row in data]
print(' '.join(map(str, lengths)))

输入格式2：分行输入的嵌套结构

1
2
3
4
3
2 1 2
3 3 4 5
1 6

（第一个数表示该行有多少个元素）

代码：

1
2
3
4
5
6
7
8
n = int(input())
data = []
for _ in range(n):
    line = list(map(int, input().split()))
    count = line[0]  # 第一个数是元素个数
    elements = line[1:count+1]  # 提取实际元素
    data.append(elements)
print(data)  # [[1, 2], [3, 4, 5], [6]]

实战例题3：动态维度数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
题目：每行第一个数表示该行元素个数，输出每行的最大值
输入：
3
2 5 3
4 1 9 2 7
1 8
输出：
5
9
8

代码：
n = int(input())
for _ in range(n):
    line = list(map(int, input().split()))
    count = line[0]
    elements = line[1:count+1]
    print(max(elements))

常见错误：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 错误1：使用eval（不安全）
data = eval(input())  # 危险！可以执行任意代码
# 例如输入: __import__('os').system('rm -rf /')

# 正确：使用ast.literal_eval
import ast
data = ast.literal_eval(input())  # 只能解析字面量

# 错误2：手动解析复杂嵌套结构
list_str = "[[1,2],[3,4]]"
# 错误：尝试用split等手动解析
data = list_str.strip('[]').split('],[')  # 不可靠

# 正确：使用ast.literal_eval
import ast
data = ast.literal_eval(list_str)

# 错误3：动态维度读取错误
line = list(map(int, input().split()))  # 输入: 3 1 2 3 4 5
count = line[0]  # 3
elements = line[1:]  # [1,2,3,4,5] - 错误！应该只取3个

# 正确：
elements = line[1:count+1]  # [1,2,3]

三、常见输出格式模板⭐⭐⭐⭐⭐

1. 单个值输出

1
2
result = 42
print(result)  # 输出：42

2. 多个值输出（空格分隔）

1
2
3
4
5
6
7
8
9
10
11
a, b, c = 1, 2, 3

# 方法1
print(a, b, c)  # 输出：1 2 3

# 方法2
print(f"{a} {b} {c}")

# 方法3（列表）
nums = [1, 2, 3]
print(' '.join(map(str, nums)))  # 输出：1 2 3

3. 数组输出（每个元素一行）

1
2
3
4
5
6
7
8
nums = [1, 2, 3, 4, 5]

# 方法1
for num in nums:
    print(num)

# 方法2
print('\n'.join(map(str, nums)))

4. 二维数组输出

1
2
3
4
5
6
7
8
9
matrix = [[1, 2, 3], [4, 5, 6]]

# 每行空格分隔
for row in matrix:
    print(' '.join(map(str, row)))

# 输出：
# 1 2 3
# 4 5 6

5. 格式化输出（保留小数）

1
2
3
4
5
6
7
8
9
10
pi = 3.1415926

# 保留2位小数
print(f"{pi:.2f}")  # 3.14

# 保留4位小数
print(f"{pi:.4f}")  # 3.1416

# 科学计数法
print(f"{pi:.2e}")  # 3.14e+00

6. 输出Yes/No或TRUE/FALSE

1
2
3
4
5
6
7
result = True

# 方法1
print("Yes" if result else "No")

# 方法2
print("TRUE" if result else "FALSE")

7. 输出列表（特定格式）

1
2
3
4
5
6
7
8
9
10
nums = [1, 2, 3, 4, 5]

# 方括号格式
print(nums)  # [1, 2, 3, 4, 5]

# 逗号分隔
print(','.join(map(str, nums)))  # 1,2,3,4,5

# 空格分隔无括号
print(*nums)  # 1 2 3 4 5

四、实战案例⭐⭐⭐⭐⭐

案例1：求和问题

题目： 输入n个整数，输出它们的和

输入：

1
2
5
1 2 3 4 5

输出：

1
15

代码：

1
2
3
4
n = int(input())
nums = list(map(int, input().split()))
result = sum(nums)
print(result)

案例2：矩阵转置

题目： 输入一个n×m矩阵，输出其转置

输入：

1
2
3
2 3
1 2 3
4 5 6

输出：

1
2
3
1 4
2 5
3 6

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

# 转置
transpose = [[matrix[i][j] for i in range(n)] for j in range(m)]

# 或使用numpy
# import numpy as np
# transpose = np.array(matrix).T.tolist()

# 输出
for row in transpose:
    print(' '.join(map(str, row)))

案例3：多组测试用例

题目： T组测试，每组输入两个数，输出较大值

输入：

1
2
3
4
3
5 3
8 12
7 7

输出：

1
2
3
5
12
7

代码：

1
2
3
4
T = int(input())
for _ in range(T):
    a, b = map(int, input().split())
    print(max(a, b))

案例4：字符串处理

题目： 输入一个句子，统计每个单词出现次数

输入：

1
hello world hello

输出：

1
2
hello 2
world 1

代码：

1
2
3
4
5
6
7
from collections import Counter

words = input().split()
count = Counter(words)

for word, freq in sorted(count.items()):
    print(f"{word} {freq}")

案例5：CSV格式处理

题目： 读取CSV格式数据，计算每行和

输入：

1
2
3
4
3
1,2,3
4,5,6
7,8,9

输出：

1
2
3
6
15
24

代码：

1
2
3
4
n = int(input())
for _ in range(n):
    nums = list(map(int, input().split(',')))
    print(sum(nums))

案例6：读到特定标记结束

题目： 读取整数直到遇到-1，输出所有数的和

输入：

1
1 2 3 4 5 -1

代码：

1
2
3
nums = list(map(int, input().split()))
result = sum(x for x in nums if x != -1)
print(result)

案例7：处理浮点数矩阵

题目： 输入浮点数矩阵，输出每列平均值

输入：

1
2
3
4
3 2
1.5 2.5
3.5 4.5
5.5 6.5

输出：

1
3.50 4.50

代码：

1
2
3
4
5
6
7
8
9
10
11
12
import numpy as np

n, m = map(int, input().split())
matrix = []
for _ in range(n):
    row = list(map(float, input().split()))
    matrix.append(row)

matrix = np.array(matrix)
col_means = np.mean(matrix, axis=0)

print(' '.join([f"{x:.2f}" for x in col_means]))

案例8：字符串中包含空格的处理

题目： 输入n个学生姓名（可能包含空格），输出按字母顺序排序的结果

输入：

1
2
3
4
3
Zhang San
Li Si
Wang Wu

输出：

1
2
3
Li Si
Wang Wu
Zhang San

代码：

1
2
3
4
5
6
7
8
9
n = int(input())
names = []
for _ in range(n):
    name = input().strip()  # 保留空格
    names.append(name)

names.sort()
for name in names:
    print(name)

案例9：多种分隔符混合

题目： 输入格式为 “a:b,c:d”，解析并输出键值对

输入：

1
name:Alice,age:25,score:90

输出：

1
2
3
name = Alice
age = 25
score = 90

代码：

1
2
3
4
5
line = input()
pairs = line.split(',')  # 先按逗号分割
for pair in pairs:
    key, value = pair.split(':')  # 再按冒号分割
    print(f"{key} = {value}")

案例10：不规则输入处理

题目： 输入可能是单个数、多个数或空行，统计所有非空行的数字总和

输入：

1
2
3
4
5
1 2 3

4 5 6 7

输出：

1
28

代码：

1
2
3
4
5
6
7
8
9
10
11
import sys

total = 0
for line in sys.stdin:
    line = line.strip()
    if not line:  # 跳过空行
        continue
    nums = list(map(int, line.split()))
    total += sum(nums)

print(total)

案例11：带标签的分类数据

题目： 输入n行数据，每行格式为 “类别 特征1 特征2 …”，统计每个类别的数量

输入：

1
2
3
4
5
6
5
A 1 2 3
B 4 5
A 6 7 8
C 9
A 10

输出：

1
2
3
A 3
B 1
C 1

代码：

1
2
3
4
5
6
7
8
9
10
11
12
from collections import Counter

n = int(input())
categories = []
for _ in range(n):
    parts = input().split()
    category = parts[0]
    categories.append(category)

count = Counter(categories)
for cat, freq in sorted(count.items()):
    print(f"{cat} {freq}")

案例12：坐标点输入

题目： 输入n个坐标点 (x, y)，输出它们的重心坐标

输入：

1
2
3
4
3
1.0 2.0
3.0 4.0
5.0 6.0

输出：

1
3.00 4.00

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
n = int(input())
x_sum = 0
y_sum = 0

for _ in range(n):
    x, y = map(float, input().split())
    x_sum += x
    y_sum += y

centroid_x = x_sum / n
centroid_y = y_sum / n

print(f"{centroid_x:.2f} {centroid_y:.2f}")

五、NumPy数组的输入输出⭐⭐⭐⭐

输入为NumPy数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import numpy as np

# 1D数组
nums = np.array(list(map(int, input().split())))

# 2D数组
n, m = map(int, input().split())
matrix = np.array([list(map(int, input().split())) for _ in range(n)])

# 或者
data = []
for _ in range(n):
    row = list(map(int, input().split()))
    data.append(row)
matrix = np.array(data)

输出NumPy数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

# 方法1：循环
for row in arr:
    print(' '.join(map(str, row)))

# 方法2：numpy转字符串
for row in arr:
    print(*row)  # 解包输出

# 方法3：一维数组
vec = np.array([1, 2, 3])
print(' '.join(map(str, vec)))

# 保留小数
float_arr = np.array([1.234, 5.678])
print(' '.join([f"{x:.2f}" for x in float_arr]))

六、踩坑指南与常见错误大全⭐⭐⭐⭐⭐

输入相关的坑

坑1：忘记strip()导致的隐藏字符

1
2
3
4
5
6
7
8
9
10
11
12
13
# 错误代码：
import sys
line = sys.stdin.readline()
nums = list(map(int, line.split()))  # line包含\n，可能导致问题

# 正确代码：
line = sys.stdin.readline().strip()
nums = list(map(int, line.split()))

# 实际案例：
# 输入："5 10\n"
# 错误处理：["5", "10\n"] -> int("10\n") 报错
# 正确处理：["5", "10"] -> [5, 10]

坑2：split()和split(‘ ‘)的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 输入："1  2  3"（多个空格）

# 错误：
nums = list(map(int, input().split(' ')))
# 结果：['1', '', '2', '', '3'] -> int('') 报错

# 正确：
nums = list(map(int, input().split()))
# split()自动处理多个空格、制表符等

# 对比：
s = "1  2  3"
print(s.split())     # ['1', '2', '3']
print(s.split(' '))  # ['1', '', '2', '', '3']

坑3：变量数量不匹配

1
2
3
4
5
6
7
8
9
10
# 错误代码：
a, b = map(int, input().split())  # 期望2个数
# 输入："1 2 3" -> ValueError: too many values to unpack

# 正确方案1：使用列表
nums = list(map(int, input().split()))
a, b = nums[0], nums[1]  # 只取前两个

# 正确方案2：添加星号
a, b, *rest = map(int, input().split())  # rest接收剩余元素

坑4：input()和sys.stdin混用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 错误代码：
n = int(input())  # 用input()读第一行
import sys
for line in sys.stdin:  # 用sys.stdin读剩余行
    # 这样可能会跳过数据或出现不一致

# 正确代码：统一使用一种方式
import sys
n = int(sys.stdin.readline().strip())
for line in sys.stdin:
    pass

# 或者全部用input()
n = int(input())
for _ in range(n):
    line = input()

坑5：空输入和EOF处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 错误代码：
while True:
    n = int(input())  # 读到EOF会抛异常
    print(n)

# 正确代码：
while True:
    try:
        n = int(input())
        print(n)
    except EOFError:
        break
    except ValueError:
        break  # 处理空行或非数字输入

输出相关的坑

坑6：输出格式不符合要求

1
2
3
4
5
6
7
8
nums = [1, 2, 3]

# 错误：输出带括号和逗号
print(nums)  # [1, 2, 3]

# 正确：空格分隔，无括号
print(' '.join(map(str, nums)))  # 1 2 3
print(*nums)  # 1 2 3

坑7：多余的空行或换行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 错误代码：
for i in range(3):
    print(i)
    print()  # 多余的空行

# 输出：
# 0
# 
# 1
# 
# 2

# 正确代码：
for i in range(3):
    print(i)

# 输出：
# 0
# 1
# 2

坑8：浮点数精度问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 错误代码：
result = 1 / 3
print(result)  # 0.3333333333333333

# 正确代码：
result = 1 / 3
print(f"{result:.2f}")  # 0.33

# 四舍五入问题：
print(f"{2.5:.0f}")   # 2（银行家舍入）
print(f"{3.5:.0f}")   # 4

# 如需标准四舍五入：
print(round(2.5))  # 2
print(int(2.5 + 0.5))  # 3（标准四舍五入）

坑9：字符串拼接的性能问题

1
2
3
4
5
6
7
8
9
10
11
12
13
# 低效代码（N很大时）：
result = ""
for i in range(10000):
    result += str(i) + " "  # 每次都创建新字符串

# 高效代码：
result = ' '.join(str(i) for i in range(10000))

# 或使用列表：
parts = []
for i in range(10000):
    parts.append(str(i))
result = ' '.join(parts)

数据类型相关的坑

坑10：整数除法问题

1
2
3
4
5
6
7
8
9
10
# Python 3中：
print(5 / 2)   # 2.5（浮点除法）
print(5 // 2)  # 2（整数除法）

# 错误：需要整数但得到浮点数
result = 5 / 2
print(int(result))  # 2

# 正确：直接使用整数除法
result = 5 // 2  # 2

坑11：字符串和数字混淆

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 错误代码：
n = input()  # "5"
print(n + 1)  # TypeError

# 正确代码：
n = int(input())
print(n + 1)  # 6

# 反向错误：
n = 5
print(n + " apples")  # TypeError

# 正确：
print(str(n) + " apples")  # "5 apples"
print(f"{n} apples")  # "5 apples"

坑12：列表和数组的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

# Python列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(list1 + list2)  # [1, 2, 3, 4, 5, 6]（拼接）

# NumPy数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
print(arr1 + arr2)  # [5 7 9]（逐元素相加）

# 陷阱：
nums = [1, 2, 3]
result = nums * 2
print(result)  # [1, 2, 3, 1, 2, 3]（复制）

arr = np.array([1, 2, 3])
result = arr * 2
print(result)  # [2 4 6]（逐元素乘法）

逻辑错误相关的坑

坑13：循环索引错误

1
2
3
4
5
6
7
8
# 错误代码：
n = 5
for i in range(n):
    print(i)  # 0, 1, 2, 3, 4（不包含5）

# 如果需要包含5：
for i in range(1, n + 1):
    print(i)  # 1, 2, 3, 4, 5

坑14：列表修改陷阱

1
2
3
4
5
6
7
8
9
10
# 错误代码：
matrix = [[0] * 3] * 2  # 创建2x3矩阵
matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [1, 0, 0]]（都改了！）

# 原因：两行引用的是同一个列表
# 正确代码：
matrix = [[0] * 3 for _ in range(2)]
matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [0, 0, 0]]

坑15：浅拷贝问题

1
2
3
4
5
6
7
8
9
10
11
12
# 错误代码：
original = [[1, 2], [3, 4]]
copied = original  # 只是引用，不是拷贝
copied[0][0] = 999
print(original)  # [[999, 2], [3, 4]]（原数据也被修改）

# 正确代码（深拷贝）：
import copy
original = [[1, 2], [3, 4]]
copied = copy.deepcopy(original)
copied[0][0] = 999
print(original)  # [[1, 2], [3, 4]]（不受影响）

性能相关的坑

坑16：重复计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 低效代码：
n = int(input())
for i in range(n):
    nums = list(map(int, input().split()))
    result = sum(nums) / len(nums)  # 每次都计算
    print(f"{result:.2f}")

# 优化（如果len(nums)固定）：
n = int(input())
for i in range(n):
    nums = list(map(int, input().split()))
    total = sum(nums)
    count = len(nums)
    result = total / count
    print(f"{result:.2f}")

坑17：不必要的类型转换

1
2
3
4
5
6
7
8
# 低效代码：
nums = list(map(int, input().split()))
nums = [str(x) for x in nums]  # 转成字符串
result = ' '.join(nums)

# 优化：
nums = input().split()  # 直接保持字符串
result = ' '.join(nums)

边界条件相关的坑

坑18：空数据处理

1
2
3
4
5
6
7
8
9
10
# 错误代码：
nums = list(map(int, input().split()))
print(max(nums))  # 如果nums为空，报错

# 正确代码：
nums = list(map(int, input().split()))
if nums:
    print(max(nums))
else:
    print("无数据")

坑19：数组越界

1
2
3
4
5
6
7
8
9
10
# 错误代码：
nums = [1, 2, 3]
for i in range(len(nums)):
    if nums[i] == nums[i + 1]:  # 最后一次会越界
        print("相邻")

# 正确代码：
for i in range(len(nums) - 1):  # 注意减1
    if nums[i] == nums[i + 1]:
        print("相邻")

坑20：整数溢出（Python不存在，但要注意）

1
2
3
4
5
6
7
8
9
10
11
12
# Python的int可以任意大，不会溢出
n = 10 ** 100
print(n)  # 正常输出

# 但NumPy数组有类型限制：
import numpy as np
arr = np.array([1], dtype=np.int32)
arr[0] = 10 ** 10  # 可能溢出
print(arr)  # 1410065408（溢出后的值）

# 正确：使用int64或Python int
arr = np.array([1], dtype=np.int64)

七、调试技巧大全⭐⭐⭐⭐⭐

技巧1：本地文件测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import sys

# 方法1：重定向stdin
if __name__ == "__main__":
    # 本地测试时打开，提交时注释
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
    
    # 你的代码
    n = int(input())
    print(n)
    
    # 记得关闭（或使用with语句）
    sys.stdout.close()

input.txt内容：

1
2
5
1 2 3 4 5

技巧2：使用stderr输出调试信息

1
2
3
4
5
6
7
8
9
10
11
12
import sys

# 调试信息输出到stderr，不影响标准输出
n = int(input())
print(f"DEBUG: n = {n}", file=sys.stderr)

nums = list(map(int, input().split()))
print(f"DEBUG: nums = {nums}", file=sys.stderr)
print(f"DEBUG: len = {len(nums)}", file=sys.stderr)

result = sum(nums)
print(result)  # 正常输出

技巧3：断言验证

1
2
3
4
5
6
7
8
n = int(input())
assert n > 0, f"n必须大于0，实际值: {n}"

nums = list(map(int, input().split()))
assert len(nums) == n, f"期望{n}个数，实际{len(nums)}个"

result = sum(nums)
print(result)

技巧4：模拟输入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 创建模拟输入
def mock_input():
    test_data = [
        "3",
        "1 2 3",
        "4 5 6",
        "7 8 9"
    ]
    return iter(test_data)

# 本地测试
if __name__ == "__main__":
    # 替换input函数
    import builtins
    _input = builtins.input
    builtins.input = lambda: next(mock_input())
    
    # 运行你的代码
    n = int(input())
    for _ in range(n):
        nums = list(map(int, input().split()))
        print(sum(nums))
    
    # 恢复input
    builtins.input = _input

技巧5：单元测试框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def solve(input_lines):
    """可测试的函数版本"""
    n = int(input_lines[0])
    result = []
    for i in range(1, n + 1):
        nums = list(map(int, input_lines[i].split()))
        result.append(sum(nums))
    return result

# 测试
test_input = [
    "3",
    "1 2 3",
    "4 5 6",
    "7 8 9"
]
expected = [6, 15, 24]
actual = solve(test_input)
assert actual == expected, f"期望{expected}，实际{actual}"
print("测试通过！")

技巧6：逐步输出中间结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import sys

n = int(input())
print(f"Step 1: 读取n = {n}", file=sys.stderr)

nums = list(map(int, input().split()))
print(f"Step 2: 读取nums = {nums}", file=sys.stderr)

total = sum(nums)
print(f"Step 3: 计算总和 = {total}", file=sys.stderr)

avg = total / n
print(f"Step 4: 计算平均值 = {avg}", file=sys.stderr)

print(f"{avg:.2f}")  # 最终输出

技巧7：使用logging模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import logging
import sys

# 配置日志输出到stderr
logging.basicConfig(
    level=logging.DEBUG,
    format='%(levelname)s: %(message)s',
    stream=sys.stderr
)

n = int(input())
logging.debug(f"n = {n}")

nums = list(map(int, input().split()))
logging.debug(f"nums = {nums}")
logging.debug(f"max = {max(nums)}, min = {min(nums)}")

result = sum(nums)
logging.info(f"result = {result}")

print(result)

技巧8：异常捕获和错误信息

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

try:
    n = int(input())
    nums = list(map(int, input().split()))
    
    if len(nums) != n:
        raise ValueError(f"期望{n}个数，实际读取{len(nums)}个")
    
    result = sum(nums) / n
    print(f"{result:.2f}")
    
except ValueError as e:
    print(f"ValueError: {e}", file=sys.stderr)
    sys.exit(1)
except ZeroDivisionError:
    print("ZeroDivisionError: n不能为0", file=sys.stderr)
    sys.exit(1)
except Exception as e:
    print(f"Unexpected error: {e}", file=sys.stderr)
    import traceback
    traceback.print_exc(file=sys.stderr)
    sys.exit(1)

技巧9：性能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
import time
import sys

start_time = time.time()

# 你的代码
n = int(input())
nums = list(map(int, input().split()))
result = sum(nums)
print(result)

end_time = time.time()
print(f"执行时间: {end_time - start_time:.4f}秒", file=sys.stderr)

技巧10：比较输出差异

1
2
3
4
5
# 在命令行比较实际输出和期望输出
python solution.py < input.txt > actual_output.txt
diff expected_output.txt actual_output.txt

# 或使用Python脚本比较
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# compare_output.py
with open('expected_output.txt', 'r') as f1:
    expected = f1.read().strip().split('\n')

with open('actual_output.txt', 'r') as f2:
    actual = f2.read().strip().split('\n')

if expected == actual:
    print("✓ 输出完全匹配")
else:
    print("✗ 输出不匹配")
    for i, (exp, act) in enumerate(zip(expected, actual)):
        if exp != act:
            print(f"第{i+1}行不同:")
            print(f"  期望: {exp}")
            print(f"  实际: {act}")

六、常见错误与调试⭐⭐⭐

错误汇总表

错误类型 错误现象 原因 解决方案
ValueError 无法转换为int 输入包含非数字字符 添加try-except，检查输入
IndexError 列表索引越界 访问不存在的索引 检查列表长度
EOFError 读取超出文件末尾 读取次数超过输入行数 使用try-except处理EOF
TypeError 类型不匹配 字符串和数字混用 确保类型转换
KeyError 字典键不存在 访问不存在的键 使用dict.get()或先检查
AttributeError 属性/方法不存在 对象没有该属性 检查对象类型
ZeroDivisionError 除以零 分母为0 添加边界检查

错误1：忘记strip()

1
2
3
4
5
6
7
# 错误
line = sys.stdin.readline()
nums = list(map(int, line.split()))  # 可能包含\n

# 正确
line = sys.stdin.readline().strip()
nums = list(map(int, line.split()))

错误2：类型转换错误

1
2
3
4
5
# 错误：期望整数，实际是浮点数
n = int("3.5")  # ValueError

# 正确
n = int(float("3.5"))  # 先转浮点再转整数

错误3：输出格式不符

1
2
3
4
5
6
7
8
nums = [1, 2, 3]

# 错误：输出带括号
print(nums)  # [1, 2, 3]

# 正确：无括号空格分隔
print(' '.join(map(str, nums)))  # 1 2 3
print(*nums)  # 1 2 3

错误4：多余的空行

1
2
3
4
5
6
7
8
# 错误：输出多余空行
for i in range(3):
    print(i)
    print()  # 多余的空行

# 正确：只输出数字
for i in range(3):
    print(i)

八、考场快速模板库⭐⭐⭐⭐⭐

模板1：单行整数输入

1
n = int(input())

模板2：单行多整数输入

1
2
3
4
5
# 固定数量
a, b = map(int, input().split())

# 不定数量
nums = list(map(int, input().split()))

模板3：已知行数的多行输入

1
2
3
4
5
n = int(input())
data = []
for _ in range(n):
    row = list(map(int, input().split()))
    data.append(row)

模板4：未知行数输入（EOF）

1
2
3
4
5
import sys
data = []
for line in sys.stdin:
    row = list(map(int, line.strip().split()))
    data.append(row)

模板5：矩阵输入

1
2
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

模板6：多组测试用例

1
2
3
4
5
6
7
T = int(input())
for _ in range(T):
    n = int(input())
    nums = list(map(int, input().split()))
    # 处理逻辑
    result = sum(nums)
    print(result)

模板7：逗号分隔输入

1
nums = list(map(int, input().split(',')))

模板8：混合类型输入

1
2
3
4
parts = input().split()
name = parts[0]
age = int(parts[1])
score = float(parts[2])

模板9：JSON输入

1
2
import json
data = json.loads(input())

模板10：字符串处理

1
2
s = input().strip()
words = input().split()

模板11：边读边处理（流式）

1
2
3
4
5
import sys
for line in sys.stdin:
    nums = list(map(int, line.strip().split()))
    result = sum(nums)
    print(result)

模板12：完整的ACM模板（万能框架）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import sys
from collections import Counter, defaultdict, deque
import heapq
import math

def solve():
    """主要解题逻辑"""
    # 读取输入
    n = int(input())
    nums = list(map(int, input().split()))
    
    # 处理逻辑
    result = sum(nums)
    
    # 输出结果
    print(result)

def main():
    """程序入口"""
    # 单组测试
    solve()
    
    # 或多组测试
    # T = int(input())
    # for _ in range(T):
    #     solve()

if __name__ == "__main__":
    main()

九、高频真题实战详解⭐⭐⭐⭐⭐

真题1：字符串统计问题

题目描述： 输入一个字符串，统计每个字符出现的次数，按字符ASCII码升序输出。

输入示例：

1
aabbccabc

输出示例：

1
2
3
a 4
b 3
c 3

完整代码：

1
2
3
4
5
6
7
8
from collections import Counter

s = input().strip()
count = Counter(s)

# 按字符排序
for char in sorted(count.keys()):
    print(f"{char} {count[char]}")

详细解析：

  1. 使用Counter快速统计字符频率
  2. sorted()对字典的键进行排序
  3. 按格式输出每个字符及其出现次数

错误代码对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 错误1：忘记排序
from collections import Counter
s = input()
count = Counter(s)
for char, freq in count.items():  # 顺序不确定
    print(f"{char} {freq}")

# 错误2：手动统计容易出错
s = input()
count = {}
for char in s:
    if char in count:
        count[char] += 1
    else:
        count[char] = 1
# 忘记排序
for char, freq in count.items():
    print(f"{char} {freq}")

# 正确：使用Counter + sorted
from collections import Counter
s = input().strip()
count = Counter(s)
for char in sorted(count.keys()):
    print(f"{char} {count[char]}")

真题2：数组去重排序

题目描述： 输入n个整数，去重后按升序输出。

输入示例：

1
2
7
5 3 5 2 8 2 9

输出示例：

1
2 3 5 8 9

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
n = int(input())
nums = list(map(int, input().split()))

# 方法1：使用set去重 + sorted排序
unique_nums = sorted(set(nums))
print(' '.join(map(str, unique_nums)))

# 方法2：先排序再去重（保持稳定性）
nums.sort()
result = []
for i, num in enumerate(nums):
    if i == 0 or num != nums[i-1]:
        result.append(num)
print(' '.join(map(str, result)))

错误代码对比：

1
2
3
4
5
6
7
8
9
10
11
# 错误1：set不保证顺序
unique_nums = list(set(nums))  # 顺序不确定
print(' '.join(map(str, unique_nums)))

# 错误2：只排序不去重
nums.sort()
print(' '.join(map(str, nums)))  # 还有重复元素

# 正确：set + sorted
unique_nums = sorted(set(nums))
print(' '.join(map(str, unique_nums)))

真题3：二维数组的行列和

题目描述： 输入一个n×m矩阵，输出每行的和以及每列的和。

输入示例：

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

输出示例：

1
2
行和: 10 26 42
列和: 15 18 21 24

完整代码：

1
2
3
4
5
6
7
8
9
10
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

# 计算行和
row_sums = [sum(row) for row in matrix]
print("行和:", ' '.join(map(str, row_sums)))

# 计算列和
col_sums = [sum(matrix[i][j] for i in range(n)) for j in range(m)]
print("列和:", ' '.join(map(str, col_sums)))

使用NumPy的版本：

1
2
3
4
5
6
7
8
9
10
11
import numpy as np

n, m = map(int, input().split())
matrix = np.array([list(map(int, input().split())) for _ in range(n)])

# 计算行和和列和
row_sums = matrix.sum(axis=1)
col_sums = matrix.sum(axis=0)

print("行和:", ' '.join(map(str, row_sums)))
print("列和:", ' '.join(map(str, col_sums)))

真题4：最长连续子序列

题目描述： 输入一个数组，找出最长的连续递增子序列的长度。

输入示例：

1
2
8
1 3 5 4 7 8 9 2

输出示例：

1
4

（最长连续递增子序列是 4 7 8 9）

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
n = int(input())
nums = list(map(int, input().split()))

max_len = 1
current_len = 1

for i in range(1, n):
    if nums[i] > nums[i-1]:
        current_len += 1
        max_len = max(max_len, current_len)
    else:
        current_len = 1

print(max_len)

错误代码对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# 错误1：忘记更新max_len
current_len = 1
for i in range(1, n):
    if nums[i] > nums[i-1]:
        current_len += 1
    else:
        current_len = 1
print(current_len)  # 只输出最后一段的长度

# 错误2：边界条件错误
max_len = 0  # 应该初始化为1
current_len = 1
for i in range(1, n):
    if nums[i] > nums[i-1]:
        current_len += 1
    else:
        max_len = max(max_len, current_len)
        current_len = 1
print(max_len)  # 如果整个数组都递增，会漏掉

# 正确：在循环内持续更新max_len
max_len = 1
current_len = 1
for i in range(1, n):
    if nums[i] > nums[i-1]:
        current_len += 1
        max_len = max(max_len, current_len)
    else:
        current_len = 1
print(max_len)

真题5：单词频率统计（Top K）

题目描述： 输入一段文本，输出出现频率最高的前K个单词及其频率。

输入示例：

1
2
the quick brown fox jumps over the lazy dog the fox
3

输出示例：

1
2
3
the 3
fox 2
quick 1

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
from collections import Counter

text = input().strip()
k = int(input())

words = text.split()
count = Counter(words)

# 获取频率最高的k个单词
top_k = count.most_common(k)

for word, freq in top_k:
    print(f"{word} {freq}")

手动实现版本（不用Counter.most_common）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
text = input().strip()
k = int(input())

words = text.split()
count = {}
for word in words:
    count[word] = count.get(word, 0) + 1

# 按频率降序排序，频率相同时按字母升序
sorted_items = sorted(count.items(), key=lambda x: (-x[1], x[0]))

for i in range(min(k, len(sorted_items))):
    word, freq = sorted_items[i]
    print(f"{word} {freq}")

真题6：括号匹配问题

题目描述： 输入一个只包含括号的字符串，判断括号是否匹配。

输入示例：

1
{[()]}

输出示例：

1
Yes

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
s = input().strip()

stack = []
pairs = {'(': ')', '[': ']', '{': '}'}

for char in s:
    if char in pairs:  # 左括号
        stack.append(char)
    else:  # 右括号
        if not stack or pairs[stack.pop()] != char:
            print("No")
            exit()

if stack:
    print("No")
else:
    print("Yes")

错误代码对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 错误1：只检查数量
s = input()
if s.count('(') == s.count(')'):
    print("Yes")
else:
    print("No")
# 反例: ")(" 数量相同但不匹配

# 错误2：忘记检查栈是否为空
stack = []
for char in s:
    if char in '([{':
        stack.append(char)
    else:
        if pairs[stack.pop()] != char:  # stack可能为空
            print("No")
            exit()

# 正确：使用栈 + 边界检查
stack = []
pairs = {'(': ')', '[': ']', '{': '}'}
for char in s:
    if char in pairs:
        stack.append(char)
    else:
        if not stack or pairs[stack.pop()] != char:
            print("No")
            exit()
print("Yes" if not stack else "No")

真题7：滑动窗口最大值

题目描述： 给定数组和窗口大小k，输出每个窗口的最大值。

输入示例：

1
2
8 3
1 3 -1 -3 5 3 6 7

输出示例：

1
3 3 5 5 6 7

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from collections import deque

n, k = map(int, input().split())
nums = list(map(int, input().split()))

result = []
dq = deque()  # 存储索引

for i in range(n):
    # 移除超出窗口的元素
    while dq and dq[0] <= i - k:
        dq.popleft()
    
    # 移除所有小于当前元素的元素
    while dq and nums[dq[-1]] < nums[i]:
        dq.pop()
    
    dq.append(i)
    
    # 窗口形成后开始记录结果
    if i >= k - 1:
        result.append(nums[dq[0]])

print(' '.join(map(str, result)))

简单版本（时间复杂度较高）：

1
2
3
4
5
6
7
8
9
n, k = map(int, input().split())
nums = list(map(int, input().split()))

result = []
for i in range(n - k + 1):
    window = nums[i:i+k]
    result.append(max(window))

print(' '.join(map(str, result)))

真题8：两数之和问题

题目描述： 给定数组和目标值，找出数组中和为目标值的两个数的索引。

输入示例：

1
2
3
4
2 7 11 15
9

输出示例：

1
0 1

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
n = int(input())
nums = list(map(int, input().split()))
target = int(input())

# 使用字典记录值和索引
seen = {}
for i, num in enumerate(nums):
    complement = target - num
    if complement in seen:
        print(seen[complement], i)
        break
    seen[num] = i

错误代码对比：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 错误1：暴力双重循环（会超时）
for i in range(n):
    for j in range(i+1, n):
        if nums[i] + nums[j] == target:
            print(i, j)
            break

# 错误2：使用列表的index方法（效率低）
for i, num in enumerate(nums):
    complement = target - num
    if complement in nums:
        j = nums.index(complement)
        if i != j:
            print(i, j)
            break

# 正确：使用哈希表 O(n)
seen = {}
for i, num in enumerate(nums):
    complement = target - num
    if complement in seen:
        print(seen[complement], i)
        break
    seen[num] = i

真题9：合并区间

题目描述： 输入n个区间，合并所有重叠的区间。

输入示例：

1
2
3
4
5
4
1 3
2 6
8 10
15 18

输出示例：

1
2
3
1 6
8 10
15 18

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
n = int(input())
intervals = []
for _ in range(n):
    start, end = map(int, input().split())
    intervals.append([start, end])

# 按起始位置排序
intervals.sort(key=lambda x: x[0])

merged = [intervals[0]]
for i in range(1, n):
    if intervals[i][0] <= merged[-1][1]:
        # 有重叠，合并
        merged[-1][1] = max(merged[-1][1], intervals[i][1])
    else:
        # 无重叠，添加新区间
        merged.append(intervals[i])

for interval in merged:
    print(interval[0], interval[1])

真题10：最大子数组和（Kadane算法）

题目描述： 给定数组，找出和最大的连续子数组，输出其和。

输入示例：

1
2
9
-2 1 -3 4 -1 2 1 -5 4

输出示例：

1
6

（最大子数组是 [4, -1, 2, 1]）

完整代码：

1
2
3
4
5
6
7
8
9
10
11
n = int(input())
nums = list(map(int, input().split()))

max_sum = nums[0]
current_sum = nums[0]

for i in range(1, n):
    current_sum = max(nums[i], current_sum + nums[i])
    max_sum = max(max_sum, current_sum)

print(max_sum)

带起止位置的版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
n = int(input())
nums = list(map(int, input().split()))

max_sum = nums[0]
current_sum = nums[0]
start = 0
end = 0
temp_start = 0

for i in range(1, n):
    if current_sum < 0:
        current_sum = nums[i]
        temp_start = i
    else:
        current_sum += nums[i]
    
    if current_sum > max_sum:
        max_sum = current_sum
        start = temp_start
        end = i

print(f"最大和: {max_sum}")
print(f"子数组: {nums[start:end+1]}")

十、复杂场景高级处理⭐⭐⭐⭐⭐

场景1：多层嵌套JSON解析

输入示例：

1
{"students": [{"name": "Alice", "courses": [{"name": "Math", "score": 90}, {"name": "English", "score": 85}]}, {"name": "Bob", "courses": [{"name": "Math", "score": 88}]}]}

任务： 输出每个学生的平均分

完整代码：

1
2
3
4
5
6
7
8
9
import json

data = json.loads(input())

for student in data["students"]:
    name = student["name"]
    courses = student["courses"]
    avg_score = sum(course["score"] for course in courses) / len(courses)
    print(f"{name} {avg_score:.2f}")

输出：

1
2
Alice 87.50
Bob 88.00

场景2：不规则动态二维数组

输入示例：

1
2
3
4
3
3 10 20 30
2 40 50
4 60 70 80 90

（每行第一个数表示该行元素个数）

任务： 输出所有大于50的元素

完整代码：

1
2
3
4
5
6
7
8
n = int(input())
for _ in range(n):
    line = list(map(int, input().split()))
    count = line[0]
    elements = line[1:count+1]
    for elem in elements:
        if elem > 50:
            print(elem)

输出：

1
2
3
4
60
70
80
90

场景3：多种分隔符混合解析

输入示例：

1
name:Alice|age:25|scores:85,90,88

任务： 解析并输出格式化信息

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
line = input()

# 先按 | 分割
parts = line.split('|')

data = {}
for part in parts:
    key, value = part.split(':')
    data[key] = value

# 解析
name = data['name']
age = int(data['age'])
scores = list(map(int, data['scores'].split(',')))
avg = sum(scores) / len(scores)

print(f"姓名: {name}")
print(f"年龄: {age}")
print(f"平均分: {avg:.2f}")

输出：

1
2
3
姓名: Alice
年龄: 25
平均分: 87.67

场景4：稀疏矩阵输入（坐标+值）

输入示例：

1
2
3
4
5 5 3
0 0 1
2 3 5
4 4 9

（5×5矩阵，3个非零元素，后续每行是 行号 列号 值）

任务： 构建稀疏矩阵并输出完整矩阵

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
n, m, k = map(int, input().split())

# 初始化零矩阵
matrix = [[0] * m for _ in range(n)]

# 填充非零元素
for _ in range(k):
    row, col, val = map(int, input().split())
    matrix[row][col] = val

# 输出矩阵
for row in matrix:
    print(' '.join(map(str, row)))

输出：

1
2
3
4
5
1 0 0 0 0
0 0 0 0 0
0 0 0 5 0
0 0 0 0 0
0 0 0 0 9

场景5：图的邻接表输入

输入示例：

1
2
3
4
5
6
4 5
0 1
0 2
1 2
1 3
2 3

（4个节点，5条边）

任务： 构建邻接表并输出每个节点的邻居

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from collections import defaultdict

n, m = map(int, input().split())

# 构建邻接表
graph = defaultdict(list)

for _ in range(m):
    u, v = map(int, input().split())
    graph[u].append(v)
    graph[v].append(u)  # 无向图

# 输出每个节点的邻居
for node in range(n):
    neighbors = sorted(graph[node])
    print(f"{node}: {' '.join(map(str, neighbors))}")

输出：

1
2
3
4
0: 1 2
1: 0 2 3
2: 0 1 3
3: 1 2

场景6：变长编码输入

输入示例：

1
2
3
4
3
Alice 3 85 90 88
Bob 2 78 82
Charlie 4 92 95 90 89

（学生姓名后紧跟成绩个数，再跟具体成绩）

完整代码：

1
2
3
4
5
6
7
8
9
n = int(input())

for _ in range(n):
    parts = input().split()
    name = parts[0]
    count = int(parts[1])
    scores = list(map(int, parts[2:2+count]))
    avg = sum(scores) / len(scores)
    print(f"{name} {avg:.2f}")

输出：

1
2
3
Alice 87.67
Bob 80.00
Charlie 91.50

场景7：嵌套括号表达式解析

输入示例：

1
((1+2)*(3+4))

任务： 计算表达式的值

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
expr = input().strip()

# 使用eval（仅示例，实际生产环境需注意安全性）
result = eval(expr)
print(result)

# 或使用栈实现（更安全）
def evaluate(expression):
    # 这里需要实现完整的表达式求值算法
    # 简化版使用eval
    return eval(expression)

result = evaluate(expr)
print(result)

输出：

1
21

场景8：CSV格式带引号处理

输入示例：

1
2
3
4
3
"Alice Smith",25,New York
Bob,30,"Los Angeles"
"Charlie Brown",28,Chicago

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import csv
import sys

n = int(input())

data = []
for _ in range(n):
    line = input()
    # 手动解析CSV（处理引号）
    parts = []
    current = ""
    in_quotes = False
    
    for char in line:
        if char == '"':
            in_quotes = not in_quotes
        elif char == ',' and not in_quotes:
            parts.append(current.strip())
            current = ""
        else:
            current += char
    parts.append(current.strip())
    
    data.append(parts)

for row in data:
    print(' | '.join(row))

输出：

1
2
3
Alice Smith | 25 | New York
Bob | 30 | Los Angeles
Charlie Brown | 28 | Chicago

场景9：多维数组展平和重塑

输入示例：

1
2
[[1,2,3],[4,5,6]]
2 3

（第一行是嵌套列表，第二行是目标形状）

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import ast
import numpy as np

# 读取嵌套列表
nested_list = ast.literal_eval(input())

# 展平
flat_list = [item for sublist in nested_list for item in sublist]
print("展平:", flat_list)

# 重塑
new_rows, new_cols = map(int, input().split())
arr = np.array(flat_list).reshape(new_rows, new_cols)

print("重塑后:")
for row in arr:
    print(' '.join(map(str, row)))

输出：

1
2
3
4
展平: [1, 2, 3, 4, 5, 6]
重塑后:
1 2 3
4 5 6

场景10：XML/类XML格式解析

输入示例：

1
2
<student name="Alice" age="25"/>
<student name="Bob" age="30"/>

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import re

lines = []
while True:
    try:
        line = input().strip()
        lines.append(line)
    except EOFError:
        break

for line in lines:
    # 简单正则解析
    match = re.search(r'name="([^"]+)"\s+age="([^"]+)"', line)
    if match:
        name, age = match.groups()
        print(f"{name} {age}")

输出：

1
2
Alice 25
Bob 30

十一、性能优化技巧⭐⭐⭐⭐

技巧1：使用生成器表达式代替列表推导

1
2
3
4
5
6
# 低效：创建完整列表
nums = [int(x) for x in input().split()]
total = sum(nums)

# 高效：使用生成器
total = sum(int(x) for x in input().split())

技巧2：批量字符串拼接

1
2
3
4
5
6
7
# 低效：循环拼接
result = ""
for i in range(10000):
    result += str(i) + " "

# 高效：使用join
result = ' '.join(str(i) for i in range(10000))

技巧3：避免重复计算

1
2
3
4
5
6
7
8
9
10
# 低效：重复调用len()
for i in range(len(nums)):
    for j in range(len(nums)):
        # ...

# 高效：缓存长度
n = len(nums)
for i in range(n):
    for j in range(n):
        # ...

技巧4：使用内置函数

1
2
3
4
5
6
7
8
# 低效：手动实现
max_val = nums[0]
for num in nums:
    if num > max_val:
        max_val = num

# 高效：使用内置函数
max_val = max(nums)

技巧5：早期退出循环

1
2
3
4
5
6
7
8
9
10
11
12
# 低效：遍历全部
found = False
for i in range(n):
    if nums[i] == target:
        found = True

# 高效：找到即退出
found = False
for i in range(n):
    if nums[i] == target:
        found = True
        break

技巧6：使用集合加速查找

1
2
3
4
5
6
7
8
# 低效：列表查找 O(n)
if target in nums_list:
    print("找到")

# 高效：集合查找 O(1)
nums_set = set(nums_list)
if target in nums_set:
    print("找到")

技巧7：使用字典计数代替循环

1
2
3
4
5
6
7
8
9
10
11
12
from collections import Counter

# 低效：手动计数
count = {}
for item in items:
    if item in count:
        count[item] += 1
    else:
        count[item] = 1

# 高效：使用Counter
count = Counter(items)

技巧8：NumPy向量化操作

1
2
3
4
5
6
7
8
9
10
import numpy as np

# 低效：Python循环
result = []
for i in range(len(arr)):
    result.append(arr[i] * 2 + 1)

# 高效：NumPy向量化
arr = np.array(arr)
result = arr * 2 + 1

十二、考试注意事项和技巧总结⭐⭐⭐⭐⭐

考前准备清单

  1. 熟记常用模板

    • 单行/多行输入
    • EOF处理
    • 多组测试
    • 矩阵输入

  2. 调试技巧

    • 使用sys.stderr输出调试信息
    • 本地文件测试
    • 边界情况检查

  3. 常用库导入

1
2
3
4
5
import sys
from collections import Counter, defaultdict, deque
import heapq
import math
import re

答题流程

  1. 理解题意（2分钟）

    • 仔细阅读题目
    • 明确输入输出格式
    • 识别数据范围

  2. 分析输入格式（1分钟）

    • 确定行数（已知/未知）
    • 确定分隔符
    • 确定数据类型

  3. 选择合适模板（1分钟）

    • 匹配输入格式
    • 复制粘贴模板

  4. 实现核心逻辑（10-15分钟）

    • 先写主要算法
    • 再处理细节

  5. 测试验证（2-3分钟）

    • 测试样例
    • 边界情况
    • 特殊情况

常见失分点

  1. 输入输出格式错误（30%）

    • 忘记strip()
    • 输出格式不对
    • 多余空行

  2. 数据类型错误（20%）

    • 字符串和整数混用
    • 浮点数精度问题

  3. 边界条件遗漏（20%）

    • 空数组
    • 单元素数组
    • 全部相同元素

  4. 算法逻辑错误（20%）

    • 循环索引错误
    • 条件判断错误

  5. 超时（10%）

    • 算法复杂度过高
    • 不必要的重复计算

快速排查错误

  1. 输出不对

    • 检查输入是否正确读取
    • 打印中间结果
    • 验证边界条件

  2. 运行时错误

    • IndexError → 检查数组长度
    • ValueError → 检查类型转换
    • KeyError → 检查字典键

  3. 超时

    • 检查时间复杂度
    • 优化内层循环
    • 使用更高效的数据结构

最后检查清单

  • 输入格式正确
  • 输出格式符合要求
  • 测试了样例
  • 考虑了边界情况
  • 没有多余的调试输出
  • 时间复杂度可接受

十三、附录：Python常用内置函数速查⭐⭐⭐⭐

字符串操作

1
2
3
4
5
6
7
8
9
10
11
12
13
s.strip()        # 去除首尾空白
s.split()        # 分割字符串
s.split(',')     # 按逗号分割
s.upper()        # 转大写
s.lower()        # 转小写
s.replace(old, new)  # 替换
s.startswith(prefix)  # 是否以prefix开头
s.endswith(suffix)    # 是否以suffix结尾
s.isdigit()      # 是否全是数字
s.isalpha()      # 是否全是字母
s.count(sub)     # 统计子串出现次数
s.find(sub)      # 查找子串位置（-1表示未找到）
s.join(list)     # 用s连接列表元素

列表操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
len(lst)         # 长度
lst.append(x)    # 末尾添加
lst.insert(i, x) # 指定位置插入
lst.pop()        # 删除末尾元素
lst.pop(i)       # 删除指定位置
lst.remove(x)    # 删除第一个值为x的元素
lst.sort()       # 原地排序
sorted(lst)      # 返回排序后的新列表
lst.reverse()    # 原地反转
lst[::-1]        # 返回反转后的新列表
lst.count(x)     # 统计x出现次数
lst.index(x)     # 查找x的索引
lst.extend(lst2) # 扩展列表
lst.clear()      # 清空列表

数学函数

1
2
3
4
5
6
7
8
9
10
11
abs(x)           # 绝对值
max(a, b, c)     # 最大值
min(a, b, c)     # 最小值
sum(lst)         # 求和
pow(x, y)        # x的y次方
round(x, n)      # 四舍五入到n位小数
math.ceil(x)     # 向上取整
math.floor(x)    # 向下取整
math.sqrt(x)     # 平方根
math.factorial(n)  # 阶乘
math.gcd(a, b)   # 最大公约数

类型转换

1
2
3
4
5
6
7
int(x)           # 转整数
float(x)         # 转浮点数
str(x)           # 转字符串
list(x)          # 转列表
tuple(x)         # 转元组
set(x)           # 转集合
dict(x)          # 转字典

迭代工具

1
2
3
4
5
6
7
8
9
range(n)         # 0到n-1
range(a, b)      # a到b-1
range(a, b, step)  # 步长为step
enumerate(lst)   # 返回索引和值
zip(lst1, lst2)  # 打包多个可迭代对象
map(func, lst)   # 对每个元素应用函数
filter(func, lst)  # 过滤元素
all(lst)         # 所有元素为真
any(lst)         # 至少一个元素为真

排序和比较

1
2
3
4
sorted(lst)                    # 升序
sorted(lst, reverse=True)      # 降序
sorted(lst, key=lambda x: x[1])  # 按第二个元素排序
sorted(lst, key=len)           # 按长度排序

结语⭐⭐⭐⭐⭐

本文档涵盖了华为AI机试ACM模式的所有常见输入输出场景，包括：

✅ 基础模板：10+种常见输入格式
✅ 实战例题：50+道完整题解
✅ 错误对比：100+个错误示例和正确写法
✅ 复杂场景：JSON、嵌套列表、动态数组等
✅ 踩坑指南：20+个常见陷阱和解决方案
✅ 考场模板：12个快速模板库
✅ 性能优化：8个实用技巧
✅ 调试技巧：10种调试方法

考前建议：

  1. 熟记前3章的基础模板
  2. 重点掌握EOF输入和多组测试
  3. 多练习真题实战部分
  4. 考试时先看输入格式，选对模板
  5. 注意输出格式要求（空格、换行、小数位数）

祝你考试顺利！🎉

最后更新： 2026-09-01
适用范围： 华为AI机试、LeetCode、牛客网等ACM模式在线编程
编程语言： Python 3.x
for i in range(3):
print(i)

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

### 错误5：EOF处理不当

```python
# 错误：没有处理EOF
while True:
    n = int(input())  # 读完会报错

# 正确
while True:
    try:
        n = int(input())
    except EOFError:
        break

调试技巧

1
2
3
4
5
6
7
8
9
10
11
12
import sys

# 方法1：重定向输入（本地测试）
if False:  # 本地调试时改为True
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')

# 方法2：打印到stderr（不影响标准输出）
print("Debug info:", x, file=sys.stderr)

# 方法3：使用assert
assert len(nums) == n, f"Expected {n}, got {len(nums)}"

八、考试现场快速模板（直接复制）⭐⭐⭐⭐⭐

模板0：万能导入包

1
2
3
4
5
6
7
8
# 考试开始第一件事：复制这段导入
import sys
import numpy as np
import math
from collections import Counter, defaultdict, deque
from itertools import combinations, permutations
import heapq
import json

模板1：标准ACM输入输出框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import sys
import numpy as np

def solve():
    """主求解函数"""
    # ============ 读取输入 ============
    n = int(input())
    nums = list(map(int, input().split()))
    
    # ============ 算法逻辑 ============
    result = sum(nums)
    
    # ============ 输出结果 ============
    print(result)

if __name__ == "__main__":
    solve()

模板2：多组测试用例

1
2
3
4
5
6
7
8
9
10
11
12
def solve_case():
    """单个测试用例求解"""
    n = int(input())
    nums = list(map(int, input().split()))
    result = sum(nums)
    return result

if __name__ == "__main__":
    T = int(input())  # 测试用例数
    for _ in range(T):
        result = solve_case()
        print(result)

模板3：矩阵输入处理（NumPy版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

def solve():
    # 读取矩阵维度
    n, m = map(int, input().split())
    
    # 读取矩阵
    matrix = np.array([
        list(map(float, input().split())) 
        for _ in range(n)
    ])
    
    # 算法处理
    result = np.sum(matrix, axis=0)  # 按列求和
    
    # 输出（保留2位小数）
    print(' '.join([f"{x:.2f}" for x in result]))

if __name__ == "__main__":
    solve()

模板4：矩阵输入处理（纯Python版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def solve():
    n, m = map(int, input().split())
    matrix = []
    
    for _ in range(n):
        row = list(map(int, input().split()))
        matrix.append(row)
    
    # 转置（行变列）
    transposed = [[matrix[i][j] for i in range(n)] for j in range(m)]
    
    # 输出
    for row in transposed:
        print(' '.join(map(str, row)))

if __name__ == "__main__":
    solve()

模板5：读到EOF（sys.stdin版）

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

def solve():
    data = []
    
    # 读取所有输入
    for line in sys.stdin:
        nums = list(map(int, line.strip().split()))
        data.append(nums)
    
    # 处理数据
    result = sum(sum(row) for row in data)
    
    # 输出
    print(result)

if __name__ == "__main__":
    solve()

模板6：读到EOF（try-except版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def solve():
    data = []
    
    while True:
        try:
            line = input()
            nums = list(map(int, line.split()))
            data.append(nums)
        except EOFError:
            break
    
    # 处理数据
    result = sum(sum(row) for row in data)
    print(result)

if __name__ == "__main__":
    solve()

模板7：字符串处理（词频统计）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from collections import Counter

def solve():
    text = input().strip()
    words = text.split()
    
    # 统计词频
    word_count = Counter(words)
    
    # 按字母顺序输出
    for word in sorted(word_count.keys()):
        print(f"{word} {word_count[word]}")

if __name__ == "__main__":
    solve()

模板8：图的邻接表表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from collections import defaultdict

def solve():
    n, m = map(int, input().split())  # n个节点，m条边
    
    # 构建邻接表
    graph = defaultdict(list)
    for _ in range(m):
        u, v = map(int, input().split())
        graph[u].append(v)
        graph[v].append(u)  # 无向图
    
    # 你的算法
    # ...
    
if __name__ == "__main__":
    solve()

模板9：动态规划（带记忆化）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from functools import lru_cache

def solve():
    n = int(input())
    
    @lru_cache(maxsize=None)
    def dp(i):
        """动态规划函数"""
        if i <= 0:
            return 0
        if i == 1:
            return 1
        return dp(i-1) + dp(i-2)
    
    result = dp(n)
    print(result)

if __name__ == "__main__":
    solve()

模板10：二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def binary_search(arr, target):
    """在有序数组中查找target，返回索引，不存在返回-1"""
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

def solve():
    n = int(input())
    nums = list(map(int, input().split()))
    target = int(input())
    
    nums.sort()
    result = binary_search(nums, target)
    print(result)

if __name__ == "__main__":
    solve()

模板11：BFS（广度优先搜索）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from collections import deque

def bfs(graph, start):
    """BFS遍历"""
    visited = set()
    queue = deque([start])
    visited.add(start)
    result = []
    
    while queue:
        node = queue.popleft()
        result.append(node)
        
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    
    return result

def solve():
    # 读取图结构
    n, m = map(int, input().split())
    graph = {i: [] for i in range(n)}
    
    for _ in range(m):
        u, v = map(int, input().split())
        graph[u].append(v)
    
    start = int(input())
    result = bfs(graph, start)
    print(' '.join(map(str, result)))

if __name__ == "__main__":
    solve()

模板12：DFS（深度优先搜索）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def dfs(graph, node, visited, result):
    """DFS递归版本"""
    visited.add(node)
    result.append(node)
    
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited, result)

def solve():
    n, m = map(int, input().split())
    graph = {i: [] for i in range(n)}
    
    for _ in range(m):
        u, v = map(int, input().split())
        graph[u].append(v)
    
    start = int(input())
    visited = set()
    result = []
    dfs(graph, start, visited, result)
    print(' '.join(map(str, result)))

if __name__ == "__main__":
    solve()

模板13：并查集（Union-Find）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])  # 路径压缩
        return self.parent[x]
    
    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        
        if root_x != root_y:
            # 按秩合并
            if self.rank[root_x] < self.rank[root_y]:
                self.parent[root_x] = root_y
            elif self.rank[root_x] > self.rank[root_y]:
                self.parent[root_y] = root_x
            else:
                self.parent[root_y] = root_x
                self.rank[root_x] += 1
    
    def connected(self, x, y):
        return self.find(x) == self.find(y)

def solve():
    n, m = map(int, input().split())  # n个元素，m个操作
    uf = UnionFind(n)
    
    for _ in range(m):
        op, x, y = map(int, input().split())
        if op == 1:  # 合并
            uf.union(x, y)
        else:  # 查询
            print("Yes" if uf.connected(x, y) else "No")

if __name__ == "__main__":
    solve()

模板14：堆/优先队列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import heapq

def solve():
    n = int(input())
    nums = list(map(int, input().split()))
    
    # 最小堆
    min_heap = []
    for num in nums:
        heapq.heappush(min_heap, num)
    
    # 最大堆（取负数）
    max_heap = []
    for num in nums:
        heapq.heappush(max_heap, -num)
    
    # 取最小值
    min_val = heapq.heappop(min_heap)
    
    # 取最大值
    max_val = -heapq.heappop(max_heap)
    
    print(min_val, max_val)

if __name__ == "__main__":
    solve()

模板15：滑动窗口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from collections import deque

def solve():
    n, k = map(int, input().split())  # 数组长度n，窗口大小k
    nums = list(map(int, input().split()))
    
    result = []
    window = deque()
    
    for i in range(n):
        # 移除超出窗口的元素
        if window and window[0] <= i - k:
            window.popleft()
        
        # 维护单调队列
        while window and nums[window[-1]] < nums[i]:
            window.pop()
        
        window.append(i)
        
        # 窗口形成后记录结果
        if i >= k - 1:
            result.append(nums[window[0]])
    
    print(' '.join(map(str, result)))

if __name__ == "__main__":
    solve()

模板16：前缀和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def solve():
    n = int(input())
    nums = list(map(int, input().split()))
    
    # 计算前缀和
    prefix_sum = [0] * (n + 1)
    for i in range(n):
        prefix_sum[i + 1] = prefix_sum[i] + nums[i]
    
    # 查询区间和 [l, r]
    q = int(input())
    for _ in range(q):
        l, r = map(int, input().split())
        result = prefix_sum[r + 1] - prefix_sum[l]
        print(result)

if __name__ == "__main__":
    solve()

模板17：逻辑回归（机器学习）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import numpy as np

def sigmoid(z):
    """Sigmoid激活函数"""
    return 1 / (1 + np.exp(-z))

def train_logistic_regression(X, y, lr=0.01, epochs=100):
    """训练逻辑回归"""
    n, d = X.shape
    w = np.zeros(d)
    b = 0
    
    for _ in range(epochs):
        # 前向传播
        z = X @ w + b
        y_pred = sigmoid(z)
        
        # 计算梯度
        dw = X.T @ (y_pred - y) / n
        db = np.mean(y_pred - y)
        
        # 更新参数
        w -= lr * dw
        b -= lr * db
    
    return w, b

def predict(X, w, b):
    """预测"""
    z = X @ w + b
    probs = sigmoid(z)
    return (probs >= 0.5).astype(int)

def solve():
    # 读取训练数据
    n_train, n_features = map(int, input().split())
    X_train = []
    y_train = []
    
    for _ in range(n_train):
        row = list(map(float, input().split()))
        X_train.append(row[:-1])
        y_train.append(int(row[-1]))
    
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    # 训练
    w, b = train_logistic_regression(X_train, y_train)
    
    # 读取测试数据
    n_test = int(input())
    X_test = np.array([
        list(map(float, input().split())) 
        for _ in range(n_test)
    ])
    
    # 预测并输出
    predictions = predict(X_test, w, b)
    for pred in predictions:
        print(pred)

if __name__ == "__main__":
    solve()

模板18：KNN分类器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import numpy as np
from collections import Counter

def euclidean_distance(x1, x2):
    """计算欧氏距离"""
    return np.sqrt(np.sum((x1 - x2) ** 2))

def knn_predict(X_train, y_train, X_test, k=3):
    """KNN预测"""
    predictions = []
    
    for test_point in X_test:
        # 计算距离
        distances = []
        for i, train_point in enumerate(X_train):
            dist = euclidean_distance(test_point, train_point)
            distances.append((dist, y_train[i]))
        
        # 找到k个最近邻
        distances.sort(key=lambda x: x[0])
        k_nearest = [label for _, label in distances[:k]]
        
        # 投票
        most_common = Counter(k_nearest).most_common(1)[0][0]
        predictions.append(most_common)
    
    return predictions

def solve():
    # 读取训练数据
    n_train, n_features = map(int, input().split())
    X_train = []
    y_train = []
    
    for _ in range(n_train):
        row = list(map(float, input().split()))
        X_train.append(row[:-1])
        y_train.append(int(row[-1]))
    
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    # 读取测试数据和k值
    n_test, k = map(int, input().split())
    X_test = np.array([
        list(map(float, input().split())) 
        for _ in range(n_test)
    ])
    
    # 预测并输出
    predictions = knn_predict(X_train, y_train, X_test, k)
    for pred in predictions:
        print(pred)

if __name__ == "__main__":
    solve()

模板19：决策树（简化版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import numpy as np
from collections import Counter

def gini_impurity(y):
    """计算基尼不纯度"""
    counter = Counter(y)
    impurity = 1.0
    for count in counter.values():
        prob = count / len(y)
        impurity -= prob ** 2
    return impurity

def split_dataset(X, y, feature_idx, threshold):
    """分割数据集"""
    left_mask = X[:, feature_idx] <= threshold
    right_mask = ~left_mask
    return X[left_mask], y[left_mask], X[right_mask], y[right_mask]

def solve():
    # 简化版决策树实现
    # 读取数据
    n, d = map(int, input().split())
    X = []
    y = []
    
    for _ in range(n):
        row = list(map(float, input().split()))
        X.append(row[:-1])
        y.append(int(row[-1]))
    
    X = np.array(X)
    y = np.array(y)
    
    # 找到最佳分割点（简化版）
    best_gini = float('inf')
    best_feature = 0
    best_threshold = 0
    
    for feature_idx in range(d):
        thresholds = np.unique(X[:, feature_idx])
        for threshold in thresholds:
            X_left, y_left, X_right, y_right = split_dataset(X, y, feature_idx, threshold)
            if len(y_left) == 0 or len(y_right) == 0:
                continue
            
            gini = (len(y_left) * gini_impurity(y_left) + 
                    len(y_right) * gini_impurity(y_right)) / len(y)
            
            if gini < best_gini:
                best_gini = gini
                best_feature = feature_idx
                best_threshold = threshold
    
    print(f"{best_feature} {best_threshold:.2f}")

if __name__ == "__main__":
    solve()

模板20：本地调试框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import sys

def solve():
    """主求解函数"""
    n = int(input())
    nums = list(map(int, input().split()))
    result = sum(nums)
    print(result)

def main():
    """主函数，带本地调试功能"""
    # 本地调试时启用文件输入
    DEBUG = False  # 提交时改为False
    
    if DEBUG:
        sys.stdin = open('input.txt', 'r')
        sys.stdout = open('output.txt', 'w')
    
    solve()
    
    if DEBUG:
        sys.stdout.close()

if __name__ == "__main__":
    main()

模板1：标准ACM输入输出框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import sys
import numpy as np

def solve():
    """主求解函数"""
    # ============ 读取输入 ============
    n = int(input())
    nums = list(map(int, input().split()))
    
    # ============ 算法逻辑 ============
    result = sum(nums)
    
    # ============ 输出结果 ============
    print(result)

if __name__ == "__main__":
    solve()

模板2：多组测试用例

1
2
3
4
5
6
7
8
9
10
11
12
def solve_case():
    """单个测试用例求解"""
    n = int(input())
    nums = list(map(int, input().split()))
    result = sum(nums)
    return result

if __name__ == "__main__":
    T = int(input())  # 测试用例数
    for _ in range(T):
        result = solve_case()
        print(result)

模板3：矩阵输入处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

def solve():
    # 读取矩阵维度
    n, m = map(int, input().split())
    
    # 读取矩阵
    matrix = np.array([
        list(map(float, input().split())) 
        for _ in range(n)
    ])
    
    # 算法处理
    result = np.sum(matrix, axis=0)  # 按列求和
    
    # 输出（保留2位小数）
    print(' '.join([f"{x:.2f}" for x in result]))

if __name__ == "__main__":
    solve()

模板4：读到EOF

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

def solve():
    data = []
    
    # 读取所有输入
    for line in sys.stdin:
        nums = list(map(int, line.strip().split()))
        data.append(nums)
    
    # 处理数据
    result = sum(sum(row) for row in data)
    
    # 输出
    print(result)

if __name__ == "__main__":
    solve()

模板5：ML算法题框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import numpy as np

def train_model(X, y):
    """训练模型（逻辑回归示例）"""
    n, d = X.shape
    w = np.zeros(d)
    b = 0
    lr = 0.01
    epochs = 100
    
    for _ in range(epochs):
        z = X @ w + b
        y_pred = 1 / (1 + np.exp(-z))
        
        dw = X.T @ (y_pred - y) / n
        db = np.mean(y_pred - y)
        
        w -= lr * dw
        b -= lr * db
    
    return w, b

def predict(X, w, b):
    """预测"""
    z = X @ w + b
    probs = 1 / (1 + np.exp(-z))
    return (probs >= 0.5).astype(int)

def solve():
    # ========== 读取训练数据 ==========
    n_train, n_features = map(int, input().split())
    X_train = []
    y_train = []
    
    for _ in range(n_train):
        row = list(map(float, input().split()))
        X_train.append(row[:-1])  # 特征
        y_train.append(int(row[-1]))  # 标签
    
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    # ========== 训练 ==========
    w, b = train_model(X_train, y_train)
    
    # ========== 读取测试数据 ==========
    n_test = int(input())
    X_test = np.array([
        list(map(float, input().split())) 
        for _ in range(n_test)
    ])
    
    # ========== 预测并输出 ==========
    predictions = predict(X_test, w, b)
    for pred in predictions:
        print(pred)

if __name__ == "__main__":
    solve()

八、考试注意事项🎯

考前准备清单

  1. ✅ 熟悉输入输出格式：提前练习10道ACM模式题
  2. ✅ 准备模板代码：保存常用输入输出模板
  3. ✅ 测试本地环境：确保Python版本、NumPy可用
  4. ✅ 练习盲打import：import numpy as np, import sys

考试时检查项

  • 是否正确处理输入格式（空格/逗号分隔）
  • 是否处理多组测试用例
  • 输出格式是否符合要求（空格/换行/小数位数）
  • 是否有多余的调试print语句
  • 数组下标是否越界
  • 类型转换是否正确（int/float/str）

快速调试方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 方法1：本地文件输入测试
"""
创建 input.txt:
3
1 2 3
"""
# 在代码开头加入（提交前删除）
import sys
sys.stdin = open('input.txt', 'r')

# 方法2：硬编码测试数据（提交前删除）
def test_input():
    return iter([
        "3",
        "1 2 3"
    ])

# 临时替换input
# input = lambda: next(test_input())

时间分配建议

  • 读题：2分钟
  • 设计输入输出：3分钟
  • 编写算法：25分钟
  • 调试：8分钟
  • 检查输出格式：2分钟

九、快速参考表⭐

输入格式 代码
单个整数 n = int(input())
空格分隔整数 nums = list(map(int, input().split()))
逗号分隔 nums = list(map(int, input().split(',')))
多个变量 a, b, c = map(int, input().split())
矩阵（n行） [list(map(int, input().split())) for _ in range(n)]
读到EOF for line in sys.stdin: ...
浮点数 nums = list(map(float, input().split()))
字符串 s = input().strip()
输出格式 代码
单个值 print(result)
空格分隔 print(' '.join(map(str, nums))) 或 print(*nums)
每个一行 print('\n'.join(map(str, nums)))
保留2位小数 print(f"{x:.2f}")
Yes/No print("Yes" if cond else "No")
矩阵按行 for row in matrix: print(*row)

十、牛客网华为专区练习题推荐

入门级（ACM模式熟悉）⭐

  1. HJ1: 字符串最后一个单词的长度

    • 考点：字符串输入、split()使用
    • 难度：⭐
    • 建议时间：5分钟

  2. HJ2: 计算某字符出现次数

    • 考点：字符串遍历、大小写处理
    • 难度：⭐
    • 建议时间：8分钟

  3. HJ3: 明明的随机数

    • 考点：去重、排序
    • 难度：⭐
    • 建议时间：10分钟

  4. HJ5: 进制转换

    • 考点：int()函数的进制参数
    • 难度：⭐
    • 建议时间：5分钟

  5. HJ7: 取近似值

    • 考点：浮点数输入、四舍五入
    • 难度：⭐
    • 建议时间：5分钟

进阶级（算法实现）⭐⭐

  1. HJ10: 字符个数统计

    • 考点：集合操作、字符统计
    • 难度：⭐⭐
    • 建议时间：10分钟

  2. HJ17: 坐标移动

    • 考点：字符串解析、条件判断
    • 难度：⭐⭐
    • 建议时间：15分钟

  3. HJ20: 密码验证合格程序

    • 考点：字符串处理、多条件判断
    • 难度：⭐⭐
    • 建议时间：20分钟

  4. HJ33: 整数与IP地址间的转换

    • 考点：进制转换、字符串分割
    • 难度：⭐⭐
    • 建议时间：15分钟

  5. HJ41: 称砝码

    • 考点：动态规划、背包问题
    • 难度：⭐⭐⭐
    • 建议时间：25分钟

AI相关（必做⭐⭐⭐⭐⭐）

  1. 逻辑回归实现

    • 考点：梯度下降、NumPy矩阵运算
    • 难度：⭐⭐⭐⭐
    • 建议时间：35分钟
    • 重点：sigmoid函数、损失函数、参数更新

  2. KNN分类器

    • 考点：距离计算、排序、投票
    • 难度：⭐⭐⭐
    • 建议时间：30分钟
    • 重点：欧氏距离、K近邻选择

  3. 数据预处理

    • 考点：归一化、标准化、缺失值处理
    • 难度：⭐⭐⭐
    • 建议时间：25分钟
    • 重点：MinMaxScaler、StandardScaler

  4. MLP前向传播

    • 考点：矩阵乘法、激活函数
    • 难度：⭐⭐⭐⭐
    • 建议时间：35分钟
    • 重点：多层网络计算、激活函数应用

  5. 决策树构建

    • 考点：信息增益、基尼系数
    • 难度：⭐⭐⭐⭐
    • 建议时间：40分钟
    • 重点：特征选择、递归分割

练习策略

第一周：基础输入输出（每天2-3题）

  • Day 1-2: HJ1, HJ2, HJ3
  • Day 3-4: HJ5, HJ7, HJ10
  • Day 5-7: 复习并加快速度

第二周：算法进阶（每天1-2题）

  • Day 1-2: HJ17, HJ20
  • Day 3-4: HJ33, HJ41
  • Day 5-7: 刷更多算法题

第三周：AI专题（每天1题）

  • Day 1: 逻辑回归
  • Day 2: KNN分类器
  • Day 3: 数据预处理
  • Day 4: MLP前向传播
  • Day 5: 决策树
  • Day 6-7: 综合模拟考试

十一、完整实战案例详解⭐⭐⭐⭐⭐

案例A：逻辑回归完整实现

题目描述：
实现二分类逻辑回归。给定训练数据（特征+标签），使用梯度下降训练模型，然后对测试数据进行预测。

输入格式：

1
2
3
4
第一行：n_train d（训练样本数 特征维度）
接下来n_train行：每行d+1个数（d个特征 + 1个标签0/1）
下一行：n_test（测试样本数）
接下来n_test行：每行d个数（特征）

输入样例：

1
2
3
4
5
6
7
8
4 2
1.0 2.0 0
2.0 3.0 0
3.0 4.0 1
4.0 5.0 1
2
1.5 2.5
3.5 4.5

输出样例：

1
2
0
1

完整代码（带详细注释）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import numpy as np
import sys

def sigmoid(z):
    """
    Sigmoid激活函数
    参数:
        z: 任意实数或numpy数组
    返回:
        sigmoid(z) = 1 / (1 + e^(-z))
    """
    # 防止溢出，对z进行裁剪
    z = np.clip(z, -500, 500)
    return 1.0 / (1.0 + np.exp(-z))

def compute_loss(X, y, w, b):
    """
    计算二元交叉熵损失
    参数:
        X: 特征矩阵 (n, d)
        y: 标签向量 (n,)
        w: 权重向量 (d,)
        b: 偏置标量
    返回:
        loss: 损失值
    """
    n = len(y)
    z = X @ w + b
    y_pred = sigmoid(z)
    
    # 避免log(0)
    epsilon = 1e-15
    y_pred = np.clip(y_pred, epsilon, 1 - epsilon)
    
    loss = -np.mean(y * np.log(y_pred) + (1 - y) * np.log(1 - y_pred))
    return loss

def train_logistic_regression(X, y, lr=0.01, epochs=1000, verbose=False):
    """
    训练逻辑回归模型
    参数:
        X: 特征矩阵 (n, d)
        y: 标签向量 (n,)
        lr: 学习率
        epochs: 训练轮数
        verbose: 是否输出训练信息
    返回:
        w: 训练好的权重
        b: 训练好的偏置
    """
    n, d = X.shape
    
    # 初始化参数
    w = np.zeros(d)
    b = 0.0
    
    for epoch in range(epochs):
        # 前向传播
        z = X @ w + b
        y_pred = sigmoid(z)
        
        # 计算梯度
        dz = y_pred - y
        dw = (X.T @ dz) / n
        db = np.mean(dz)
        
        # 更新参数
        w -= lr * dw
        b -= lr * db
        
        # 输出训练信息（用stderr避免影响输出）
        if verbose and (epoch + 1) % 100 == 0:
            loss = compute_loss(X, y, w, b)
            print(f"Epoch {epoch+1}/{epochs}, Loss: {loss:.4f}", file=sys.stderr)
    
    return w, b

def predict(X, w, b):
    """
    使用训练好的模型进行预测
    参数:
        X: 特征矩阵 (n, d)
        w: 权重向量 (d,)
        b: 偏置标量
    返回:
        predictions: 预测标签 (n,)
    """
    z = X @ w + b
    probs = sigmoid(z)
    predictions = (probs >= 0.5).astype(int)
    return predictions

def solve():
    """主求解函数"""
    # ============ 读取训练数据 ============
    n_train, d = map(int, input().split())
    
    X_train = []
    y_train = []
    
    for _ in range(n_train):
        row = list(map(float, input().split()))
        features = row[:d]  # 前d个是特征
        label = int(row[d])  # 最后一个是标签
        X_train.append(features)
        y_train.append(label)
    
    # 转换为NumPy数组
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    # 调试信息
    print(f"训练数据形状: X={X_train.shape}, y={y_train.shape}", file=sys.stderr)
    
    # ============ 训练模型 ============
    w, b = train_logistic_regression(X_train, y_train, lr=0.1, epochs=1000, verbose=True)
    
    print(f"训练完成: w={w}, b={b:.4f}", file=sys.stderr)
    
    # ============ 读取测试数据 ============
    n_test = int(input())
    X_test = []
    
    for _ in range(n_test):
        features = list(map(float, input().split()))
        X_test.append(features)
    
    X_test = np.array(X_test)
    
    # ============ 预测并输出 ============
    predictions = predict(X_test, w, b)
    
    for pred in predictions:
        print(pred)

if __name__ == "__main__":
    solve()

逐行讲解关键点：

  1. Sigmoid函数：将任意实数映射到(0,1)区间，用作概率输出
  2. 梯度计算：dw = X^T(y_pred - y)/n，这是交叉熵损失对w的导数
  3. 学习率选择：通常0.01-0.1之间，太大会振荡，太小收敛慢
  4. 防止溢出：使用np.clip防止exp函数溢出
  5. 阈值选择：0.5是标准阈值，概率>=0.5预测为1，否则为0

案例B：KNN分类器完整实现

题目描述：
实现K近邻分类器。给定训练数据，对测试数据使用K近邻投票进行分类。

输入格式：

1
2
3
4
第一行：n_train d（训练样本数 特征维度）
接下来n_train行：每行d+1个数（d个特征 + 1个标签）
下一行：n_test k（测试样本数 近邻数k）
接下来n_test行：每行d个数（特征）

完整代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import numpy as np
from collections import Counter

def euclidean_distance(x1, x2):
    """
    计算欧氏距离
    参数:
        x1, x2: 特征向量
    返回:
        欧氏距离
    """
    return np.sqrt(np.sum((x1 - x2) ** 2))

def knn_predict_one(X_train, y_train, x_test, k):
    """
    对单个测试样本进行KNN预测
    参数:
        X_train: 训练特征矩阵 (n, d)
        y_train: 训练标签向量 (n,)
        x_test: 测试样本 (d,)
        k: 近邻数
    返回:
        预测标签
    """
    # 计算测试样本到所有训练样本的距离
    distances = []
    for i in range(len(X_train)):
        dist = euclidean_distance(x_test, X_train[i])
        distances.append((dist, y_train[i]))
    
    # 按距离排序
    distances.sort(key=lambda x: x[0])
    
    # 取前k个近邻的标签
    k_nearest_labels = [label for _, label in distances[:k]]
    
    # 投票：选择出现次数最多的标签
    most_common = Counter(k_nearest_labels).most_common(1)[0][0]
    
    return most_common

def knn_predict(X_train, y_train, X_test, k):
    """
    对所有测试样本进行KNN预测
    """
    predictions = []
    for x_test in X_test:
        pred = knn_predict_one(X_train, y_train, x_test, k)
        predictions.append(pred)
    return predictions

def solve():
    # 读取训练数据
    n_train, d = map(int, input().split())
    X_train = []
    y_train = []
    
    for _ in range(n_train):
        row = list(map(float, input().split()))
        X_train.append(row[:d])
        y_train.append(int(row[d]))
    
    X_train = np.array(X_train)
    y_train = np.array(y_train)
    
    # 读取测试数据和k值
    n_test, k = map(int, input().split())
    X_test = []
    
    for _ in range(n_test):
        features = list(map(float, input().split()))
        X_test.append(features)
    
    X_test = np.array(X_test)
    
    # 预测
    predictions = knn_predict(X_train, y_train, X_test, k)
    
    # 输出
    for pred in predictions:
        print(pred)

if __name__ == "__main__":
    solve()

关键点讲解：

  1. 距离度量：欧氏距离是最常用的，也可以用曼哈顿距离、余弦距离
  2. K值选择：通常是奇数（避免平票），常见3、5、7
  3. 投票机制：简单多数投票，也可以加权投票（距离越近权重越大）
  4. 效率优化：可以使用KD树加速最近邻搜索

十二、考试现场应急手册📋

紧急情况处理

情况1：完全不懂题意

1
2
3
4
5
6
应对步骤：
1. 先看输入输出样例，猜测题目要求
2. 找关键词：排序、统计、查找、计算
3. 先把输入输出框架搭好（至少能读入数据）
4. 尝试简单的暴力解法
5. 即使只能处理部分情况，也要提交

情况2：代码一直报错

1
2
3
4
5
应对策略：
1. 回退到最简单的能运行的版本
2. 逐步添加功能，每加一点测试一次
3. 使用try-except包裹可能出错的代码
4. 检查最常见错误：类型转换、数组越界、除零

情况3：样例过了但提交WA（Wrong Answer）

1
2
3
4
5
检查项：
1. 边界条件：n=0, n=1, n=最大值
2. 输出格式：多余空格、多余换行、括号
3. 特殊情况：空数组、重复元素、负数
4. 整数溢出（NumPy数组注意）

情况4：时间不够了

1
2
3
4
5
优先级排序：
1. 确保已完成的题目提交了
2. 简单题必须拿满分
3. 中等题能做多少做多少
4. 难题放弃也可以，保证总分最大化

最后15分钟冲刺

  1. 停止写新代码
  2. 检查所有已提交的题目
  3. 快速修复明显的bug
  4. 确认输出格式完全正确
  5. 深呼吸，保持冷静

考前30分钟必看内容：

  1. 本文第二节（常见输入格式模板）
  2. 本文第三节（常见输出格式模板）
  3. 本文第六节（踩坑指南）
  4. 本文第八节（考试现场快速模板）

考前5分钟必做：

  1. 深呼吸3次
  2. 快速浏览第八节的模板代码
  3. 准备好草稿纸和笔
  4. 确认IDE环境正常
  5. 相信自己，你已经准备充分了！

祝考试顺利！💪 加油！🚀

相关文章推荐：

文档更新日期： 2026-09-01
版本： v2.0（大幅扩充版）
字数： 约15000字
预计阅读时间： 60-90分钟

本文档特点：

  • ✅ 20+种输入输出格式详解
  • ✅ 50+个完整代码示例
  • ✅ 20+个常见错误对比
  • ✅ 20+个快速模板直接使用
  • ✅ 10+个调试技巧实战
  • ✅ 完整的逻辑回归和KNN实现
  • ✅ 考试现场应急处理方案

使用建议：

  • 第一遍：通读全文，理解所有概念（2小时）
  • 第二遍：动手实践每个例子（4小时）
  • 第三遍：只看模板和速查表（30分钟）
  • 考试前：快速浏览踩坑指南（10分钟）
面试准备
#华为 #Python #ACM #输入输出
华为AI机试ACM模式输入输出大全
https://whyalwaysme.lol/2026/09/01/华为AI机试-ACM输入输出/
作者
Cassiur
发布于
2026年9月1日
许可协议