每日一题——Python实现PAT乙级1037 在霍格沃茨找零钱（举一反三+思想解读+逐步优化）

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

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

Python-3.12.0文档解读

我的写法

时间复杂度分析：

空间复杂度分析：

我要更强

哲学和编程思想

1. 模块化（Modularity）

2. DRY原则（Don't Repeat Yourself）

3. 抽象化（Abstraction）

4. 代码的可读性（Readability）

5. 函数式编程思想（Functional Programming）

举一反三

1. 进一步封装和抽象

2. 优化数据处理

3. 提高代码质量

4. 写作干净且有意义的代码

5. 遵循设计模式

6. 代码简洁性和性能

题目链接

我的写法

# 从用户输入获取两个货币值P和A，并以空格分隔
P, A = input().split()

# 将输入的货币值P和A根据点号'.'分解成列表，并将字符串转换成整数
P = list(map(int, P.split('.')))
A = list(map(int, A.split('.')))

# 计算货币P的总纳特数，加隆乘以17再乘以29，西可乘以29，纳特直接相加
P = (17 * P[0]) * 29 + (P[1] * 29) + P[2]
# 计算货币A的总纳特数，同上
A = (17 * A[0]) * 29 + (A[1] * 29) + A[2]

# 判断A是否小于P，若是，则信号为负号'-'
signal = '-' if A < P else ''

# 计算P和A的绝对差值，并将差额转换回原来的货币格式，即加隆.西可.纳特
changes = [abs(A - P) // (29 * 17),   # 加隆数，用总差值除以一个加隆的纳特数
           abs(A - P) // 29 % 17,      # 西可数，用总差值除以一西可的纳特数取余数再对17取余数
           abs(A - P) % 29]            # 纳特数，用总差值对29取余数

# 格式化输出结果，如果是负差额，前面会有负号
print(f"{signal}{changes[0]}.{changes[1]}.{changes[2]}")

这段代码是一个针对特殊货币系统的差额计算器。它使用简单的数学转换和模运算来计算和格式化两个货币输入之间的差额。这是一个非常专门化的工具，可能适用于某些游戏或特殊的货币转换场景。

时间复杂度分析：

分割输入的字符串和转换为整数列表是 O(n) 操作，其中 n 是输入字符串的长度。
两次的货币转换操作（计算P和A的总纳特数）是 O(1) 操作，因为这里只涉及到有限的几个乘法和加法运算。
计算差额和转换回原货币格式同样是 O(1) 操作，因为无论输入多大，这里的操作数都是固定的。

综上所述，整个操作的时间复杂度是 O(n)，主要是由于对输入字符串进行分割和转换。

空间复杂度分析：

输入字符串被存储为两个额外的列表 P 和 A，这需要 O(m) 的空间，其中 m 是输入字符串分割成列表后元素的总数。
其他操作如货币的转换和差额计算使用了常数空间，因为它们存储了固定数量的变量。

因此，整个操作的空间复杂度是 O(m)，主要由输入数据的存储决定。

整体评价：代码本身比较简洁，并且直接了当地完成了任务。它正确地利用了整数除法和取余，来计算差额并将其分解成不同的货币单位。这样的代码对于处理货币计算的小型任务来说是有效且足够的。

不过，代码在健壮性方面有待改进。例如，它没有检查输入的格式是否正确（是否为三部分数字），也没有检查数字是否在合理范围内。在实际应用中，这些都是应该要考虑的因素。此外，如果这段代码要集成到一个大型的应用中，最好为这个功能封装成函数，这样可以提高代码的可读性和可重用性。

我要更强

这段代码实际上已经是相当高效的。它的时间复杂度在处理单次输入的情况下是 O(n)，其中n是输入字符串的长度。因为字符串长度在这里是用户输入的，无法预先确定，所以无法优化输入分割的时间复杂度。

空间复杂度同样是 O(m)，其中m是分割后的输入元素总数。由于每个输入字符串都需要被分割和转换为整数进行计算，这是必须占用的空间。

然而，如果考虑到这个脚本可能会被多次调用或者处理多个输入，可以通过创建函数来重复使用相同的代码，这样可以提高代码的可读性和可重用性。在函数中处理每对输入，将有助于保持全局命名空间的清洁，并减少潜在的错误。

以下是改进后的代码及注释：

def calculate_currency_difference(P, A):
    # 转换货币值为整数的纳特数
    P_knuts = (17 * P[0]) * 29 + (P[1] * 29) + P[2]
    A_knuts = (17 * A[0]) * 29 + (A[1] * 29) + A[2]

    # 判断需要输出的信号（正数还是负数）
    signal = '-' if A_knuts < P_knuts else ''

    # 计算差值并转换成货币格式
    diff = abs(A_knuts - P_knuts)
    galleons = diff // (29 * 17)
    sickles = (diff // 29) % 17
    knuts = diff % 29

    # 返回格式化的货币差值字符串
    return f"{signal}{galleons}.{sickles}.{knuts}"

# 主函数，用于读取输入和输出结果
def main():
    P_input, A_input = input("Enter two currencies separated by space (e.g., 3.12.1 5.15.21): ").split()
    P = list(map(int, P_input.split('.')))
    A = list(map(int, A_input.split('.')))
    print(calculate_currency_difference(P, A))

# 调用主函数
if __name__ == "__main__":
    main()

在这段代码中，将计算的部分封装成了 calculate_currency_difference 函数，接受两个分解为列表的货币值 P 和 A。主函数 main 负责读取用户输入，并将输入转化为所需的格式，然后调用 calculate_currency_difference 函数并打印结果。

这段代码保持了原有算法的时间复杂度和空间复杂度，但增加了可读性和可重用性。由于输入操作是用户驱动的，它们的效率依赖于用户输入的长度和数量，这些不是通过算法优化能够改变的。储存输入和计算差值的操作已经是最优的，因为它们分别是由输入大小和固定的变量数决定的。