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

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

Python-3.12.0文档解读

目录

初次尝试

 再次尝试

代码点评

代码结构

时间复杂度

空间复杂度

优化建议

我要更强

优化建议

完整代码及注释

时间复杂度和空间复杂度分析

进一步优化

哲学和编程思想

模块化设计：

抽象化：

效率优化：

迭代和递归：

预先计算和缓存：

错误处理和异常管理：

数据驱动设计：

简洁性：

举一反三

---

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

初次尝试

import sys
input = sys.stdin.read
print = sys.stdout.write

def mod13(num):
    return "0123456789JQK"[num]

# 读取输入
A, B = input().strip().split()

len_A = len(A)
len_B = len(B)
output = ''

# 从后向前遍历字符
for i in range(1, min(len_A, len_B) + 1):
    if i % 2 == 1:  # 奇数位
        output = mod13((int(A[-i]) + int(B[-i])) % 13) + output
    else:  # 偶数位
        result = int(B[-i]) - int(A[-i])
        if result < 0:
            result += 10
        output = str(result) + output

# 如果B比A长，直接拼接剩余部分
if len_B > len_A:
    output = B[:len_B-len_A] + output

# 输出结果
print(output + '\n')

题目没说如果长度不同就用0补齐，但是得补齐

 再次尝试

import sys

# 读取输入
input_data = sys.stdin.readline().strip()
A, B = input_data.split()

# 初始化输出字符串
output = ''

# 从最低位开始处理，即从后往前遍历
len_A = len(A)
len_B = len(B)
max_len = max(len_A, len_B)

for i in range(1, max_len + 1):
    # 获取A和B的当前位数字
    a_digit = int(A[-i]) if i <= len_A else 0
    b_digit = int(B[-i]) if i <= len_B else 0
    
    # 根据奇偶位进行加密运算
    if i % 2 == 1:  # 奇数位
        result = (a_digit + b_digit) % 13
        if result == 10:
            output = 'J' + output
        elif result == 11:
            output = 'Q' + output
        elif result == 12:
            output = 'K' + output
        else:
            output = str(result) + output
    else:  # 偶数位
        diff = b_digit - a_digit
        if diff < 0:
            diff += 10
        output = str(diff) + output

# 输出加密后的结果
print(output)

代码点评

这段代码实现了两个字符串的加密处理，其中每个字符串代表一个数字序列。加密规则如下：

1. 对于奇数位（从右往左数），将两个字符串对应位置的数字相加，结果模13，然后转换为特定的字符（10->'J', 11->'Q', 12->'K'）或保持为数字。
2. 对于偶数位，计算第二个字符串对应位置的数字减去第一个字符串对应位置的数字，如果结果为负，则加10。

代码结构

• 使用sys.stdin.readline()读取输入，这通常用于处理标准输入，适用于命令行交互。
• 通过strip()和split()方法处理输入，确保输入格式正确。
• 使用循环从后往前遍历字符串，处理每个位置的加密逻辑。
• 输出结果前，通过字符串拼接构建最终的加密结果。

时间复杂度

• 时间复杂度为O(n)，其中n是两个输入字符串的最大长度。这是因为代码中有一个循环，循环次数等于最大字符串长度。

空间复杂度

• 空间复杂度也是O(n)，主要用于存储输入字符串和输出字符串。输入字符串的长度决定了所需的额外空间。

优化建议

• 考虑输入的边界情况，例如输入为空字符串或非数字字符的情况。
• 可以优化字符串拼接的方式，使用str.join()方法代替+操作，以提高效率。
• 对于输入的错误处理可以更加健壮，例如添加异常处理机制。

总体来说，这段代码逻辑清晰，时间复杂度和空间复杂度都是线性的，适用于处理中等长度的字符串加密。

---

我要更强

优化建议

1. 字符串拼接优化：使用str.join()代替+操作，因为+操作在每次执行时都会创建新的字符串对象，而join()方法预先计算所需空间，效率更高。
2. 输入处理优化：可以预先检查输入的有效性，确保输入的是数字字符串。
3. 循环内部优化：减少不必要的类型转换和条件判断。

完整代码及注释

import sys

# 读取输入
input_data = sys.stdin.readline().strip()
A, B = input_data.split()

# 初始化输出字符串
output = []

# 从最低位开始处理，即从后往前遍历
len_A = len(A)
len_B = len(B)
max_len = max(len_A, len_B)

for i in range(1, max_len + 1):
    # 获取A和B的当前位数字
    a_digit = int(A[-i]) if i <= len_A else 0
    b_digit = int(B[-i]) if i <= len_B else 0
    
    # 根据奇偶位进行加密运算
    if i % 2 == 1:  # 奇数位
        result = (a_digit + b_digit) % 13
        if result == 10:
            output.append('J')
        elif result == 11:
            output.append('Q')
        elif result == 12:
            output.append('K')
        else:
            output.append(str(result))
    else:  # 偶数位
        diff = b_digit - a_digit
        if diff < 0:
            diff += 10
        output.append(str(diff))

# 输出加密后的结果
print(''.join(output[::-1]))

时间复杂度和空间复杂度分析

• 时间复杂度：O(n)，其中n是两个输入字符串的最大长度。循环遍历每个字符一次。
• 空间复杂度：O(n)，主要用于存储输出字符串。使用列表output存储中间结果，最后通过join()方法转换为字符串。

进一步优化

• 可以考虑使用更高效的输入输出方法，例如使用文件或更快的输入输出库。
• 对于大量数据处理，可以考虑使用更高效的算法或数据结构，例如使用数组代替字符串处理。

这段代码已经相对高效，适用于处理中等长度的字符串加密任务。

---

哲学和编程思想

在上述代码优化中，涉及到的哲学和编程思想主要包括：

1. 模块化设计：

   • 代码被分解为多个小部分，每个部分负责一个特定的任务（如输入处理、加密计算、输出构建）。这种模块化的设计使得代码更易于理解和维护，同时也便于测试和调试。

2. 抽象化：

   • 通过将具体的加密逻辑抽象为对每个位置的处理，代码避免了直接处理复杂的加密规则，使得逻辑更加清晰和易于管理。

3. 效率优化：

   • 使用str.join()代替+操作来优化字符串拼接，这是基于对Python字符串操作的深入理解。字符串在Python中是不可变的，每次使用+操作都会创建一个新的字符串对象，而join()方法则预先计算所需空间，减少了内存分配和复制操作。

4. 迭代和递归：

   • 代码使用迭代（循环）来处理字符串的每个位置，而不是递归。迭代通常比递归更高效，因为它避免了函数调用的开销和潜在的栈溢出问题。

5. 预先计算和缓存：

   • 在循环中预先计算可能的边界条件（如字符串长度不足时的默认值），减少了每次迭代中的条件判断。这种预先计算可以减少运行时的计算量，提高效率。

6. 错误处理和异常管理：

   • 虽然代码中没有显式的异常处理，但通过预先检查输入的有效性，可以避免潜在的运行时错误。这种预防性的编程思想有助于构建更健壮的系统。

7. 数据驱动设计：

   • 代码的逻辑主要围绕数据（字符串的每个位置）进行，通过处理数据来驱动加密逻辑的执行。这种设计使得代码更加灵活，易于适应不同的数据输入。

8. 简洁性：

• 代码力求简洁明了，避免不必要的复杂性和冗余。简洁的代码不仅易于阅读和理解，也减少了出错的可能性。

这些编程思想和哲学不仅适用于上述代码的优化，也是软件工程和编程实践中广泛应用的原则。通过这些思想的应用，可以提高代码的质量、可维护性和效率。

---

举一反三

基于上述哲学和编程思想，以下是一些技巧和建议，可以帮助你在编程中举一反三，提高代码质量和效率：

1. 模块化与单一职责原则：
   • 确保每个函数或模块只做一件事，并且做好这件事。这有助于提高代码的可读性和可维护性。
   • 使用函数或类来封装相关的功能，使得代码结构清晰，易于理解和修改。
2. 抽象化与接口设计：
   • 设计抽象的接口或基类，隐藏具体实现细节，使得代码更加灵活和可扩展。
   • 使用抽象数据类型（如列表、字典）来表示复杂的数据结构，而不是直接操作底层数据。
3. 效率优化与性能分析：
   • 使用性能分析工具（如Python的cProfile）来识别代码中的瓶颈。
   • 优化循环和递归，避免不必要的计算和内存分配。
   • 使用合适的数据结构和算法，例如使用集合（set）来快速查找元素，使用字典（dict）来存储键值对。
4. 迭代与递归的合理选择：
   • 对于深度不大的问题，可以考虑使用递归，它可以使代码更简洁。
   • 对于深度不确定或可能很大的问题，优先考虑迭代，以避免栈溢出。
5. 预先计算与缓存：
   • 对于重复的计算，使用缓存（如字典或数组）来存储中间结果，避免重复计算。
   • 在循环中预先计算边界条件，减少每次迭代中的条件判断。
6. 错误处理与异常管理：
   • 使用异常处理来优雅地处理错误，而不是通过返回错误码。
   • 在代码中适当位置添加断言（assert），以确保程序状态的正确性。
7. 数据驱动设计与测试驱动开发（TDD）：
   • 编写测试用例来驱动代码的开发，确保每个功能都按预期工作。
   • 使用数据驱动的方法来设计测试用例，覆盖尽可能多的边界情况和异常情况。
8. 简洁性与可读性：

• 编写简洁、清晰的代码，避免过度复杂的逻辑和嵌套。
• 使用有意义的变量名和函数名，编写详细的注释，帮助他人理解代码的意图。

通过应用这些技巧，可以在编程中更加高效和有条理，同时也能够提高代码的质量和可维护性。记住，编程不仅仅是实现功能，更是一种艺术和科学的结合，需要不断地学习和实践。

---