1. 项目概述：从作业到实战的思维跃迁

最近在整理资料时，翻到了当年在西工大NOJ平台上刷题的记录，特别是71到80这十道题。现在回头看，这绝不仅仅是十次作业提交，而是一个完整的编程思维训练闭环。很多同学把NOJ作业当成任务，做完提交就完事，但真正的高手会把这些题目当成“麻雀”，解剖清楚每一行代码背后的逻辑、每一个算法选择的理由，以及如何把这些零散的知识点串联成解决实际问题的能力。这十道题覆盖了字符串处理、列表操作、递归思想、简单算法以及面向对象的初步接触，是Python从语法熟悉到初级应用的关键跳板。如果你正在为这些题目挠头，或者感觉Python学了一堆语法却不知道如何下手写一个完整的程序，那么跟着我重新拆解一遍这十道题，你收获的将不仅是十个“Accepted”，更是一套可迁移的解题心法和工程化编码习惯。

2. 核心解题思路与通用方法论

面对任何编程题目，尤其是OJ系统的题目，盲目动手敲代码是大忌。一套高效的解题流程，能帮你节省大量调试时间，并显著提升代码质量。

2.1 五步拆题法：把问题吃透再动手

我的习惯是，无论题目难易，都遵循以下五个步骤：

1. 精确理解题意：这是最重要也最容易被忽视的一步。逐字阅读题目描述，用笔划出输入格式、输出格式、以及所有的约束条件（比如数据范围、特殊规则）。例如，题目要求“从小到大输出”，就不能输出成从大到小；要求“结果保留两位小数”，就不能输出整数。很多“Wrong Answer”都源于审题不清。
2. 设计测试用例：在编码前，自己设计3-5组测试数据，包括常规情况、边界情况（如空输入、最大值、最小值）和极端情况。用这些数据在脑子里模拟一遍你的算法，验证逻辑是否正确。这相当于提前做了一次白盒测试。
3. 选择数据结构与算法：根据问题特征，选择最合适的数据结构（列表、字典、集合、元组）和算法（遍历、排序、查找、递归）。例如，需要快速判断元素是否存在，就用set；需要记录键值对映射，就用dict；需要处理先入后出的顺序，可以考虑list模拟栈。
4. 编写伪代码或画出流程图：对于复杂逻辑，先用中文或简单的代码结构把步骤写下来。这能帮你理清思路，避免边写边想导致的逻辑混乱。流程图对于有分支和循环的题目尤其有效。
5. 编码与测试：最后才是动手写代码。写完后，立即用第二步设计的测试用例进行验证，然后再提交到OJ平台。

2.2 NOJ平台特性与编码注意事项

西工大NOJ平台通常使用标准输入(input())和标准输出(print())进行评测。有几个细节需要特别注意：

注意：平台评测往往是多组测试数据连续运行。你的程序需要能处理不确定行数的输入，直到文件结束(EOF)。一个健壮的写法是使用try-except块或sys.stdin来读取。

import sys # 方法一：使用sys.stdin.read()或sys.stdin.readlines()一次读取所有行 for line in sys.stdin: data = line.strip() if not data: # 有时需要跳过空行 continue # 处理逻辑 # 方法二：使用带异常的循环（适用于本地测试和部分OJ） while True: try: line = input() if not line: # 同样，注意处理可能的空行 continue # 处理逻辑 except EOFError: break

另外，注意输出格式必须严格匹配，多一个空格、少一个换行都可能导致“Presentation Error”。在打印多个结果时，使用‘ ‘.join(map(str, result_list))来控制空格，用print()自带换行来控制行尾，是更稳妥的方式。

3. 作业71-80核心题目精讲与举一反三

这里我挑选其中最具代表性、最能锻炼思维的几道题进行深度剖析，并提供不止一种解法，讲解背后的权衡。

3.1 字符串与列表综合处理题（典型代表）

这类题目通常涉及字符串分割、列表排序、过滤和格式化输出。

假设一道题目的核心要求是：输入一行包含多个整数的字符串，请去除其中的重复数字，然后按升序排序输出。

初级解法（直观但低效）：

# 假设输入: “3 1 2 2 4 3 5” nums = input().split() # 得到[‘3‘, ‘1‘, ‘2‘, ‘2‘, ‘4‘, ‘3‘, ‘5’] unique_nums = [] for num in nums: if num not in unique_nums: # 这里每次‘in‘操作都是O(n)的线性查找 unique_nums.append(num) result = sorted(unique_nums, key=int) # 排序 print(‘ ‘.join(result))

问题分析：在for循环中，每次判断num not in unique_nums，都需要对unique_nums列表进行一次遍历。当数据量增大时，时间复杂度接近O(n²)，效率很低。

进阶解法（利用集合去重）：

nums = map(int, input().split()) # 直接转换为整数 unique_sorted_nums = sorted(set(nums)) # 利用集合去重，再排序 print(‘ ‘.join(map(str, unique_sorted_nums)))

思路提升：set()是Python中基于哈希表实现的无序不重复元素集。in操作的平均时间复杂度是O(1)，远优于列表的O(n)。一行代码sorted(set(nums))就优雅地解决了去重和排序两个问题。这教会我们，选择合适的数据结构是优化代码的第一要义。

举一反三：如果题目要求“保持原有输入顺序去除重复项”呢？这时set因为无序性就不适用了。我们可以利用字典在Python 3.7+后保持插入顺序的特性，或者用一个辅助列表：

from collections import OrderedDict # 或者直接用dict（Python 3.7+） nums = input().split() # 使用dict.fromkeys可以保留首次出现的顺序 unique_ordered = list(dict.fromkeys(nums)) print(‘ ‘.join(unique_ordered))

3.2 递归与分治思想入门题

NOJ在这十题中可能会安排一道经典的递归问题，比如斐波那契数列、汉诺塔或者求最大公约数（GCD）。递归是理解函数式编程和复杂算法的基础。

以计算斐波那契数列第n项为例：

def fibonacci_naive(n): """朴素递归，存在大量重复计算，效率极低""" if n <= 1: return n return fibonacci_naive(n-1) + fibonacci_naive(n-2)

这个解法虽然直观，但时间复杂度是恐怖的O(2^n)，计算fib(40)就可能需要数秒。这是因为计算fib(n)时会重复计算fib(n-2),fib(n-3)等子问题无数次。

优化方案一：使用缓存（记忆化搜索）

from functools import lru_cache @lru_cache(maxsize=None) def fibonacci_memo(n): """使用LRU缓存装饰器，自动存储已计算结果""" if n <= 1: return n return fibonacci_memo(n-1) + fibonacci_memo(n-2)

@lru_cache是Python标准库提供的装饰器，它会自动缓存函数调用的结果。当用相同参数再次调用时，直接返回缓存值，将时间复杂度降为O(n)。

优化方案二：迭代法（动态规划思想）

def fibonacci_iter(n): """迭代法，效率最高，空间复杂度O(1)""" if n <= 1: return n a, b = 0, 1 for _ in range(2, n+1): a, b = b, a + b # 同时更新，避免使用临时变量 return b

这是最优解法，只用常数级别的额外空间，时间复杂度O(n)。通过这个例子，我们要理解递归的本质和优化方向：递归描述思路，迭代提升效率。在作业中，如果n不大，可以用朴素递归；但如果题目暗示n可能很大，就必须考虑迭代或记忆化。

3.3 简单算法实现题（如排序、查找）

自己实现基础算法，是理解算法原理的关键。NOJ可能会要求你不使用内置的sorted()函数实现排序。

实现一个简单的冒泡排序：

def bubble_sort(arr): """冒泡排序，原地修改列表""" n = len(arr) for i in range(n): # 标记该轮是否发生交换，若未发生则说明已有序，可提前结束 swapped = False for j in range(0, n-i-1): # 最后i个元素已就位 if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] # 交换 swapped = True if not swapped: # 提前结束优化 break return arr

关键点讲解：

1. n-i-1：每一轮排序后，最大的元素会“冒泡”到末尾，因此内层循环的范围逐渐减小。
2. swapped优化：这是冒泡排序的一个经典优化。如果某一轮没有发生任何交换，说明列表已经有序，可以立即终止循环，避免无谓的比较。
3. 原地排序：直接在原列表arr上操作，没有创建新列表，节省了内存空间。

实操心得：自己实现算法时，务必在代码中添加详细的注释，说明每一步的目的和循环变量的含义。这不仅有助于自己调试，也是良好的编程习惯。在NOJ上，这类题目通常不追求极致的性能（因为数据量小），但追求逻辑的清晰和正确。

3.4 面向对象编程(OOP)的初探

可能在80题左右，会引入最简单的类和对象概念。例如，定义一个Student类，包含姓名、学号、成绩属性，并实现一个计算平均分的方法。

class Student: def __init__(self, sid, name): """初始化方法，创建对象时自动调用""" self.sid = sid # 学号 self.name = name # 姓名 self.scores = [] # 成绩列表 def add_score(self, score): """添加一门课的成绩""" if 0 <= score <= 100: self.scores.append(score) else: print(f"成绩{score}无效，应在0-100之间") def get_average(self): """计算平均分""" if not self.scores: # 避免除零错误 return 0.0 return sum(self.scores) / len(self.scores) def __str__(self): """定义打印对象时的格式""" avg = self.get_average() return f"学生[学号：{self.sid}, 姓名：{self.name}, 平均分：{avg:.2f}]" # 使用示例 if __name__ == "__main__": stu = Student("2023001", "张三") stu.add_score(85) stu.add_score(92) stu.add_score(78) print(stu) # 输出：学生[学号：2023001, 姓名：张三, 平均分：85.00]

OOP要点解析：

1. __init__：构造方法，用于初始化新创建对象的状态。self代表实例本身，是类方法的第一个参数（调用时自动传入）。
2. __str__：魔法方法。当你使用print(obj)或str(obj)时，Python会自动调用这个方法。定义它可以让对象打印出来更友好，而不是一堆内存地址。
3. 封装：将数据（属性）和操作数据的方法捆绑在一起。外部代码通过定义好的方法（如add_score）来修改内部数据，而不是直接访问scores列表，这更安全、更易维护。

对于作业级别的OOP题目，重点在于理解“类”是蓝图、“对象”是实例，以及如何使用self来访问属性和方法。

4. 调试技巧与常见“坑点”实录

即使思路正确，代码也常常因为一些细节问题而无法AC。下面是我和同学们当年踩过的一些典型“坑”。

4.1 输入输出格式陷阱

坑点1：多组数据输入中的空白行有些题目输入数据以空行结束，或者数据块之间用空行分隔。如果直接用input().strip()，空行会被处理成空字符串‘’。你需要判断：

while True: line = input().strip() if line == ‘’: # 遇到空行，可能表示一组数据结束或输入结束 # 处理当前组数据，或准备结束 process_current_group() # 可能需要再读一行看是否还有数据，或直接break break # 或 continue else: # 正常处理数据 data = line.split()

坑点2：输出末尾多余空格或换行OJ评测有时会严格检查输出格式。避免在行末打印多余空格。

# 错误示例：打印列表元素，每个后面跟空格 result = [1, 2, 3] for num in result: print(num, end=‘ ‘) # 这会输出“1 2 3 ”，最后多一个空格 # 正确示例1：使用join print(‘ ‘.join(map(str, result))) # 输出“1 2 3” # 正确示例2：手动控制最后一个元素 for i, num in enumerate(result): if i == len(result) - 1: print(num) # 最后一个元素换行 else: print(num, end=‘ ‘) # 非最后一个元素加空格

4.2 数据类型转换与精度问题

坑点3：整数除法与浮点数精度Python 3中，/是真除法，返回浮点数；//是地板除，返回整数。在需要输出整数时误用/，可能导致输出像5.0这样的形式，与期望的5不符。

a = 10 b = 3 print(a / b) # 输出 3.3333333333333335 print(a // b) # 输出 3 print(int(a / b)) # 输出 3，但先产生浮点数，再转换

在涉及浮点数比较时，直接使用==可能因精度问题出错。应判断两者差的绝对值是否小于一个极小值（如1e-9）。

# 判断两个浮点数是否“相等” def is_close(a, b, rel_tol=1e-9): return abs(a - b) <= rel_tol

坑点4：列表的引用与拷贝这是一个高级但常见的错误。当你用=将一个列表赋值给另一个变量时，你只是创建了一个新的引用，而不是一份拷贝。修改其中一个，另一个也会变。

list_a = [1, 2, 3] list_b = list_a # list_b只是list_a的一个别名（引用） list_b.append(4) print(list_a) # 输出 [1, 2, 3, 4]！list_a也被修改了 # 正确做法：使用拷贝 list_b = list_a.copy() # 浅拷贝 # 或 list_b = list_a[:] # 切片操作也是浅拷贝 # 对于嵌套列表，可能需要深拷贝：import copy; list_b = copy.deepcopy(list_a)

4.3 算法效率与边界条件

坑点5：忽视时间复杂度，导致超时(TLE)即使代码逻辑正确，如果算法复杂度太高，对于大数据量也会超时。例如，用冒泡排序(O(n²))处理10万个数据，几乎必然超时。在做题前，务必根据题目给出的数据范围（如 n ≤ 10^5）估算算法复杂度。n=10^5时，O(n²)的算法是不可接受的，至少需要O(n log n)的算法（如快速排序、归并排序）。

坑点6：边界条件考虑不周这是导致“Wrong Answer”的主要原因之一。务必考虑：

• 空输入：输入字符串为空、列表为空时，你的程序会崩溃吗？
• 极值：输入为最大值、最小值时，变量会溢出吗？循环条件还成立吗？
• 初始状态：递归的基准条件（base case）是否覆盖了所有可能？动态规划的初始值设置对了吗？

例如，在实现二分查找时，循环条件while left <= right和while left < right的选择，以及中间值mid = (left + right) // 2的写法，都需要根据问题仔细斟酌，否则极易陷入死循环或漏查。

5. 从作业到项目：构建你的代码工具箱

完成NOJ作业不是终点，而是起点。真正的能力提升在于归纳总结，形成自己的“代码工具箱”。

5.1 建立常用代码片段库

将解题过程中反复用到的、经过验证的代码块保存下来。例如：

• 快速输入模板（针对不同格式）：

  # 读取单行多个整数 nums = list(map(int, input().split())) # 读取确定行数n，再读n行数据 n = int(input()) data = [input().strip() for _ in range(n)] # 读取不定行直到EOF import sys lines = [line.strip() for line in sys.stdin if line.strip()]

• 常用工具函数：

  def is_prime(n): """判断一个正整数是否为质数""" if n < 2: return False if n == 2: return True if n % 2 == 0: return False i = 3 while i * i <= n: if n % i == 0: return False i += 2 return True def gcd(a, b): """欧几里得算法求最大公约数""" while b: a, b = b, a % b return a def lcm(a, b): """求最小公倍数""" return a * b // gcd(a, b)

5.2 培养工程化编码习惯

作业代码往往“能用就行”，但项目代码需要可读、可维护、可测试。

1. 命名规范：使用有意义的英文变量名和函数名。student_list比s1好，calculate_average比ca好。遵循小写蛇形命名法（snake_case）。
2. 函数单一职责：一个函数只做一件事。不要把所有的逻辑都堆在main或一个函数里。将输入、处理、输出分离。
3. 添加注释与文档字符串：在函数定义下用“““ ”””写明函数的作用、参数和返回值。在复杂的逻辑块前添加行注释。
4. 防御性编程：对输入数据进行合法性检查。例如，转换int前先判断是否为数字字符串；访问列表元素前先判断索引是否越界。

5.3 下一步学习路径建议

搞定这十道题后，你的Python基础已经比较扎实了。接下来可以沿着以下几个方向深化：

• 数据结构深化：学习collections模块（deque,defaultdict,Counter,OrderedDict），它们在特定场景下比内置类型更高效。
• 算法入门：系统学习时间/空间复杂度分析，以及排序、查找、递归、动态规划、贪心等基础算法。可以尝试LeetCode或洛谷的简单题目。
• 面向对象设计：理解继承、多态、封装，学习设计模式的基础知识，尝试用类来组织更复杂的程序。
• 实用库学习：根据兴趣，学习requests（网络请求）、beautifulsoup4或Scrapy（网页爬虫）、pandas（数据分析）、matplotlib（数据可视化）等库，用Python解决实际问题。

编程就像搭积木，NOJ的每一道题都是一块积木。起初你只是照图纸摆放，但当你积累足够多，理解了每一块的形状和承重，你就能自由地创造属于自己的建筑。这71-80题，就是帮你认识这些基础积木的关键一步。别只满足于AC，多问几个“为什么”，多试几种“怎么办”，你收获的会远超一份满分的作业成绩。