每日一题——8行Python代码实现PAT乙级1029 旧键盘(举一反三+思想解读+逐步优化)五千字好文


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

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

Python-3.12.0文档解读

目录

​编辑我的写法

代码分析

时间复杂度分析

空间复杂度分析

改进建议

方法 1:原地修改法

分析

方法 2:使用双指针

分析

方法 3:递归法

分析

方法 4:迭代法

分析

哲学和编程思想

1. 原地算法(In-Place Algorithm)

2. 迭代(Iteration)

3. 递归(Recursion)

4. 双指针(Two Pointers)

5. 分治法(Divide and Conquer)

6. 优化(Optimization)

7. 简洁性(Simplicity)

举一反三

1. 原地算法(In-Place Algorithm)

2. 迭代(Iteration)

3. 递归(Recursion)

4. 双指针(Two Pointers)

5. 分治法(Divide and Conquer)

6. 优化(Optimization)

7. 简洁性(Simplicity)

实践建议


题目链接

我的写法

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        str_num=''
        for digit in digits:
            str_num+=str(digit)
        
        return [int(digit) for digit in str(int(str_num)+1)]

这段代码定义了一个名为 Solution 的类,其中包含一个方法 plusOne,该方法接受一个整数列表 digits 作为输入,并返回一个新的整数列表。这个方法的目的是将列表中的数字视为一个整数,然后加1,最后将结果转换回整数列表。

代码分析

  1. 字符串拼接:首先,代码通过遍历输入的整数列表 digits,将每个整数转换为字符串,并拼接成一个完整的字符串 str_num。
  2. 整数加法:接着,将字符串 str_num 转换为整数,加1,然后再转换回字符串。
  3. 列表生成:最后,使用列表推导式将字符串中的每个字符转换为整数,并返回这个整数列表。

时间复杂度分析

  • 字符串拼接:遍历整个 digits 列表,时间复杂度为 O(n),其中 n 是列表的长度。
  • 整数加法和转换:这部分操作的时间复杂度可以视为常数 O(1)。
  • 列表生成:再次遍历字符串,时间复杂度为 O(n)。

因此,总的时间复杂度为 O(n) + O(1) + O(n) = O(n)。

空间复杂度分析

  • 字符串 str_num:需要额外的空间来存储字符串,空间复杂度为 O(n)。
  • 中间变量:整数加法和转换过程中使用的中间变量空间复杂度为 O(1)。
  • 结果列表:最终生成的列表空间复杂度为 O(n)。

因此,总的空间复杂度为 O(n) + O(1) + O(n) = O(n)。

改进建议

这段代码虽然实现了功能,但可以通过更直接的方式来优化,避免不必要的字符串转换和拼接。例如,可以直接在整数列表上进行操作,通过模拟进位的方式来实现加1的操作,这样可以减少空间的使用,并且可能提高执行效率。

这种方法的时间复杂度仍然是 O(n),但空间复杂度优化到了 O(1),因为它避免了额外的字符串和列表生成。


我要更强

对于这个问题,直接将整数列表视为一个大整数加1,并不需要复杂的操作。最有效的方法依然是逐位处理进位,虽然时间复杂度已经是最优的 O(n),但可以在空间上再做优化。下面我会给出几种不同的优化方法,尽量降低空间复杂度和时间复杂度。

方法 1:原地修改法

这是通过原地修改输入列表来实现加1操作,同时确保空间复杂度保持在 O(1)。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        n = len(digits)
        for i in range(n - 1, -1, -1):
            if digits[i] < 9:
                digits[i] += 1
                return digits
            digits[i] = 0
        
        # 处理进位到新的最高位
        return [1] + [0] * n
分析
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)(不考虑输入和输出空间)

方法 2:使用双指针

双指针的方法可以避免不必要的遍历,但在这种特定问题上,双指针的优化空间不大。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        left, right = 0, len(digits) - 1
        
        while right >= 0:
            if digits[right] < 9:
                digits[right] += 1
                return digits
            digits[right] = 0
            right -= 1
        
        return [1] + [0] * len(digits)
分析
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)(不考虑输入和输出空间)

方法 3:递归法

递归法可以优雅地处理进位问题,但在空间上会因为递归深度而增加。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        def helper(index):
            if index < 0:
                return [1] + digits
            
            if digits[index] < 9:
                digits[index] += 1
                return digits
            
            digits[index] = 0
            return helper(index - 1)
        
        return helper(len(digits) - 1)
分析
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)(由于递归调用栈)

方法 4:迭代法

迭代法是最为常见且高效的方法。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(len(digits) - 1, -1, -1):
            if digits[i] < 9:
                digits[i] += 1
                return digits
            digits[i] = 0
        
        return [1] + [0] * len(digits)
分析
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)(不考虑输入和输出空间)

以上几种方法中,方法 1 和方法 4 都是时间复杂度为 O(n),空间复杂度为 O(1)。递归法虽然优雅,但递归深度会影响空间复杂度,通常不推荐用于这种简单的线性问题。


哲学和编程思想

这些方法体现了多种哲学和编程思想,具体包括:

1. 原地算法(In-Place Algorithm)

  • 哲学思想:最小化额外空间的使用,强调资源的高效利用。
  • 编程思想:通过修改输入数据本身来减少对额外空间的需求。在方法1和方法4中,我们直接修改输入的digits列表,而不是创建一个新的列表来存储结果。

2. 迭代(Iteration)

  • 哲学思想:通过重复执行一组操作来解决问题,强调逐步逼近解决方案。
  • 编程思想:使用循环结构(如for或while循环)来重复执行代码块,直到满足某个条件。在方法1、方法4和方法2中,我们使用迭代来遍历整数列表并处理进位。

3. 递归(Recursion)

  • 哲学思想:将复杂问题分解为更简单的子问题,强调问题的分解和层次化解决。
  • 编程思想:通过调用自身来解决问题,每次调用都解决问题的较小部分。在方法3中,我们使用递归来处理进位,每次递归调用处理一个较低位的加法。

4. 双指针(Two Pointers)

  • 哲学思想:通过同时从两端处理数据来提高效率,强调对问题的深入理解和针对性解决方案。
  • 编程思想:使用两个指针分别指向数据结构的不同位置,通常用于数组或链表问题。在方法2中,我们使用双指针来减少不必要的遍历。

5. 分治法(Divide and Conquer)

  • 哲学思想:将大问题分解为小问题,分别解决后再合并结果,强调问题的分解和合并。
  • 编程思想:虽然在这个特定问题中没有直接使用分治法,但递归的思想与分治法紧密相关。递归通常涉及将问题分解为更小的子问题,然后解决这些子问题。

6. 优化(Optimization)

  • 哲学思想:追求算法效率的最大化,强调性能和资源的最佳利用。
  • 编程思想:通过选择最合适的算法和数据结构来提高程序的运行效率。在所有方法中,我们都试图通过减少不必要的操作和空间使用来优化解决方案。

7. 简洁性(Simplicity)

  • 哲学思想:追求代码的简洁性和可读性,强调清晰和易于理解的解决方案。
  • 编程思想:编写简洁、直观的代码,避免不必要的复杂性。方法1和方法4的代码相对简单,易于理解和维护。

这些哲学和编程思想不仅适用于这个问题,也是编程和算法设计中的通用原则,可以帮助开发者更有效地解决问题。


举一反三

1. 原地算法(In-Place Algorithm)

  • 技巧:尽量通过修改输入数据或现有数据结构来解决问题,而不是创建新的数据结构。这可以减少内存使用并提高效率。
  • 应用:在处理数组或列表问题时,考虑是否可以通过交换元素或修改元素值来达到目的,而不是创建新的数组。

2. 迭代(Iteration)

  • 技巧:使用循环结构来重复执行一组操作,直到满足某个条件。
  • 应用:在需要重复执行相同或类似操作的问题中,使用for循环、while循环或迭代器来简化代码。

3. 递归(Recursion)

  • 技巧:将问题分解为更小的子问题,并通过递归调用解决这些子问题。
  • 应用:在处理可以自然分解为子问题的问题时,考虑使用递归。例如,树或图的遍历、分治算法等。

4. 双指针(Two Pointers)

  • 技巧:使用两个指针从不同方向遍历数据结构,以减少遍历次数或找到特定条件下的解决方案。
  • 应用:在数组或链表问题中,当需要找到两个元素之间的关系时,考虑使用双指针技巧。

5. 分治法(Divide and Conquer)

  • 技巧:将大问题分解为小问题,分别解决后再合并结果。
  • 应用:在处理可以自然分解为独立子问题的问题时,使用分治法。例如,快速排序、归并排序等。

6. 优化(Optimization)

  • 技巧:选择最合适的算法和数据结构,以提高程序的运行效率。
  • 应用:在设计算法时,考虑时间复杂度和空间复杂度,选择最优的解决方案。

7. 简洁性(Simplicity)

  • 技巧:编写简洁、直观的代码,避免不必要的复杂性。
  • 应用:在编写代码时,尽量使代码清晰易懂,避免过度设计。使用有意义的变量名和函数名,保持代码结构的一致性。

实践建议

  • 学习经典算法和数据结构:了解和掌握常见的算法和数据结构,如排序算法、搜索算法、树、图等。
  • 解决实际问题:通过解决实际问题来应用这些技巧,例如通过在线编程挑战或项目实践。
  • 代码审查和重构:定期审查自己的代码,寻找改进的机会,重构代码以提高其质量和效率。
  • 学习他人的解决方案:查看其他人在类似问题上的解决方案,学习他们的方法和技巧。

通过实践这些技巧,能够更好地理解和应用各种编程和算法设计思想,从而在面对新问题时能够灵活运用,举一反三。


  • 16
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

用哲学编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值