每日一题——Python实现PAT乙级1073 多选题常见计分法（举一反三+思想解读+逐步优化）9千字好文

本文链接：https://blog.youkuaiyun.com/weixin_44915521/article/details/140085779

一个认为一切根源都是“自己不够强”的INTJ

个人主页：用哲学编程-优快云博客
专栏：每日一题——举一反三
 Python编程学习
 Python内置函数

题目链接：https://pintia.cn/problem-sets/994805260223102976/exam/problems/type/7?problemSetProblemId=994805263624683520&page=0

初次尝试

N_students_num, M_ques_num = map(int, input().split())  # 读取学生人数和题目数量
answers = {}  # 初始化答案字典
for i in range(M_ques_num):
    full_score, option_num, right_option_num, *right_options = input().split()
    full_score = int(full_score)
    option_num = int(option_num)
    right_option_num = int(right_option_num)
    #print(full_score, option_num, right_option_num, *right_options)
    #3 4 2 a c
    answers[i+1] = [right_option_num, ''.join(right_options), full_score, option_num]  # 将题目的正确选项和分数等信息存入字典

#print(answers)
#{1: [2, 'ac', 3, 4], 2: [1, 'b', 2, 5], 3: [2, 'bc', 5, 3], 4: [4, 'abde', 1, 5]}

options_wrong_times = {}  # 初始化错误选项次数字典

for i in range(N_students_num):
    student_options = input()
    student_options = student_options.replace(' ', '')
    student_options = student_options.replace(')', '')
    student_options = student_options[1:].split('(')
    #print(student_options)
    #['2ac', '2bd', '2ac', '3abe']
    for j in range(M_ques_num):
        student_options[j] = int(student_options[j][0]), student_options[j][1:]  # 将学生答案转换为元组列表，每个元组包含选项数量和选项字符串
    #print(student_options)
    #[(2, 'ac'), (2, 'bd'), (2, 'ac'), (3, 'abe')]
    this_student_score = 0
    for j in range(M_ques_num):
        if answers[j+1][0] == student_options[j][0] and answers[j+1][1] == student_options[j][1]:
            this_student_score += answers[j+1][2]  # 完全正确，加上全部分数
            continue
        elif set(student_options[j][1]) < set(answers[j+1][1]):
            this_student_score += 0.5 * answers[j+1][2]  # 部分正确，加上一半分数
            
        wrong_options = list(set(student_options[j][1]) ^ set(answers[j+1][1]))  # 计算错误选项
        wrong_options.sort()
        for option in wrong_options:
            if str(j+1) + '-' + option not in options_wrong_times:
                options_wrong_times[str(j+1) + '-' + option] = 1  # 记录错误选项次数
            else:
                options_wrong_times[str(j+1) + '-' + option] += 1

    print(f"{this_student_score:.1f}")  # 输出每个学生的得分

if len(options_wrong_times) == 0:
    print("Too simple")  # 如果没有错误选项，输出"Too simple"
else:
    tmp = max(options_wrong_times.values())
    output = [option for option in options_wrong_times if options_wrong_times[option] == tmp]
    for i in range(len(output)):
        print(tmp, output[i])  # 输出错误次数最多的选项及其错误次数

再次尝试

N_students_num, M_ques_num = map(int, input().split())  # 读取学生人数和题目数量
answers = {}  # 初始化答案字典
for i in range(M_ques_num):
    full_score, option_num, right_option_num, *right_options = input().split()
    full_score = int(full_score)
    option_num = int(option_num)
    right_option_num = int(right_option_num)
    answers[i+1] = [right_option_num, set(right_options), full_score]  # 将题目的正确选项和分数等信息存入字典

options_wrong_times = {}  # 初始化错误选项次数字典

for i in range(N_students_num):
    student_options = input().replace(' ', '').replace(')', '')[1:].split('(')
    student_options = [set(opt[1:]) for opt in student_options]  # 将学生答案转换为集合列表
    this_student_score = 0
    for j in range(M_ques_num):
        student_option_set = student_options[j]
        correct_option_set = answers[j+1][1]
        if student_option_set == correct_option_set:
            this_student_score += answers[j+1][2]  # 完全正确，加上全部分数
        elif student_option_set.issubset(correct_option_set):
            this_student_score += 0.5 * answers[j+1][2]  # 部分正确，加上一半分数
            
        wrong_options = student_option_set.symmetric_difference(correct_option_set)  # 计算错误选项
        for option in wrong_options:
            key = f"{j+1}-{option}"
            options_wrong_times[key] = options_wrong_times.get(key, 0) + 1  # 记录错误选项次数

    print(f"{this_student_score:.1f}")  # 输出每个学生的得分

if not options_wrong_times:
    print("Too simple")  # 如果没有错误选项，输出"Too simple"
else:
    max_wrong_times = max(options_wrong_times.values())
    for option, times in sorted(options_wrong_times.items(), key=lambda x: (int(x[0].split('-')[0]), x[0].split('-')[1])):
        if times == max_wrong_times:
            print(max_wrong_times, option)  # 输出错误次数最多的选项及其错误次数

有何不同

这两个版本的代码在功能上是相同的，都是为了计算每个学生的得分并找出错得最多的题目选项。然而，它们在实现上有一些差异，主要体现在代码的简洁性、效率和可读性上。以下是两个版本的主要差异分析：

版本一（原始版本）：

字符串操作较多：
- 使用多次字符串替换和分割操作，例如 student_options = student_options.replace(' ', '').replace(')', '') 和 student_options = student_options[1:].split('(')。
- 将学生答案转换为元组列表，例如 student_options[j] = int(student_options[j][0]), student_options[j][1:]。
使用列表和集合操作：
- 使用列表操作来处理学生答案和正确答案，例如 wrong_options = list(set(student_options[j][1]) ^ set(answers[j+1][1]))。
- 使用集合操作来判断部分正确的情况，例如 set(student_options[j][1]) < set(answers[j+1][1])。
错误选项次数的记录：
- 使用字典来记录错误选项次数，例如 options_wrong_times[str(j+1) + '-' + option] = 1。
输出错误次数最多的选项：

使用列表推导式来找出错误次数最多的选项，例如 output = [option for option in options_wrong_times if options_wrong_times[option] == tmp]。

版本二（优化版本）：

减少字符串操作：
- 通过一次性的字符串替换和分割操作，减少了多次的字符串操作，例如 student_options = input().replace(' ', '').replace(')', '')[1:].split('(')。
使用集合操作：
- 将学生答案和正确答案都转换为集合，利用集合的快速操作，例如 student_options = [set(opt[1:]) for opt in student_options] 和 correct_option_set = answers[j+1][1]。
错误选项次数的记录：
- 使用字典的 get 方法来简编辑文章化错误选项次数的更新，例如 options_wrong_times[key] = options_wrong_times.get(key, 0) + 1。
输出错误次数最多的选项：

使用排序来确保输出顺序正确，例如 for option, times in sorted(options_wrong_times.items(), key=lambda x: (int(x[0].split('-')[0]), x[0].split('-')[1]))。

总结：

优化版本在代码简洁性、效率和可读性上都有所提升。
优化版本减少了不必要的字符串操作，利用集合操作提高了处理速度。
优化版本使用字典的 get 方法简化了错误选项次数的更新，并使用排序确保输出顺序正确。

总体来说，优化版本在性能和代码质量上都有显著提升。

这段代码的主要功能是计算每个学生的得分，并找出错得最多的题目选项。下面是对这段代码的专业点评，包括时间复杂度和空间复杂度的分析。

代码结构和逻辑

输入处理：
- 首先读取学生人数 N_students_num 和题目数量 M_ques_num。
- 然后读取每个题目的详细信息（包括满分、选项数量、正确选项数量和正确选项）并存储在字典 answers 中。
学生得分计算：
- 对于每个学生，读取其答案并转换为集合列表。
- 计算每个学生的得分，并记录每个错误选项的出现次数。
输出结果：

输出每个学生的得分。
如果没有错误选项，输出 "Too simple"。
否则，输出错误次数最多的选项及其错误次数。

时间复杂度分析

初始化答案字典：
- 这部分的时间复杂度是 O(M)，其中 M 是题目数量。
学生得分计算：
- 对于每个学生，需要处理其答案并计算得分。这部分的时间复杂度是 O(N * M)，其中 N 是学生人数，M 是题目数量。
- 在计算得分时，需要比较学生答案和正确答案，这部分的时间复杂度是 O(M * K)，其中 K 是每个题目的选项数量。
- 记录错误选项的出现次数，这部分的时间复杂度是 O(M * K)。
输出结果：

输出每个学生的得分，这部分的时间复杂度是 O(N)。
输出错误次数最多的选项，这部分的时间复杂度是 O(M * K log(M * K))，因为需要对错误选项进行排序。

综合来看，整个代码的时间复杂度是 O(N * M * K + M * K log(M * K))。

空间复杂度分析

答案字典：
- 存储每个题目的详细信息，空间复杂度是 O(M * K)。
错误选项次数字典：
- 存储每个错误选项的出现次数，空间复杂度是 O(M * K)。
学生答案：

存储每个学生的答案，空间复杂度是 O(N * M * K)。

综合来看，整个代码的空间复杂度是 O(N * M * K)。

总结

时间复杂度：O(N * M * K + M * K log(M * K))
空间复杂度：O(N * M * K)

这段代码在逻辑上是清晰的，但在处理大量数据时可能会面临性能问题。特别是当 N、M 和 K 都很大时，时间复杂度和空间复杂度都会显著增加。优化方向可以考虑减少不必要的字符串操作和集合操作，以及优化数据结构的使用。

我要更强

优化时间复杂度和空间复杂度的方法通常涉及减少不必要的计算和数据结构的使用。以下是一些可能的优化方法，并附上相应的代码和注释。

优化方法

减少字符串操作：减少不必要的字符串替换和分割操作。
使用高效的集合操作：利用集合的快速操作来减少比较时间。
避免重复计算：缓存一些计算结果以避免重复计算。
优化数据结构：选择合适的数据结构来存储和处理数据。

优化后的代码

from collections import defaultdict

# 读取学生人数和题目数量
N_students_num, M_ques_num = map(int, input().split())

# 初始化答案字典
answers = {}
for i in range(M_ques_num):
    full_score, option_num, right_option_num, *right_options = input().split()
    answers[i+1] = [int(right_option_num), set(right_options), int(full_score)]

# 初始化错误选项次数字典
options_wrong_times = defaultdict(int)

# 计算每个学生的得分并记录错误选项次数
for _ in range(N_students_num):
    student_options = input().replace(' ', '').replace(')', '')[1:].split('(')
    student_options = [set(opt[1:]) for opt in student_options]
    this_student_score = 0
    for j in range(M_ques_num):
        student_option_set = student_options[j]
        correct_option_set = answers[j+1][1]
        if student_option_set == correct_option_set:
            this_student_score += answers[j+1][2]
        elif student_option_set.issubset(correct_option_set):
            this_student_score += 0.5 * answers[j+1][2]
        
        wrong_options = student_option_set.symmetric_difference(correct_option_set)
        for option in wrong_options:
            key = f"{j+1}-{option}"
            options_wrong_times[key] += 1

    print(f"{this_student_score:.1f}")

# 输出错误次数最多的选项
if not options_wrong_times:
    print("Too simple")
else:
    max_wrong_times = max(options_wrong_times.values())
    for option, times in sorted(options_wrong_times.items(), key=lambda x: (int(x[0].split('-')[0]), x[0].split('-')[1])):
        if times == max_wrong_times:
            print(max_wrong_times, option)

优化说明

减少字符串操作：
- 使用 input().replace(' ', '').replace(')', '')[1:].split('(') 一次性完成字符串替换和分割操作。
使用高效的集合操作：
- 使用集合的 symmetric_difference 方法来计算错误选项，这比手动比较更高效。
避免重复计算：
- 使用 defaultdict 来简化错误选项次数的更新，避免重复的 get 操作。
优化数据结构：