每日一题——Python实现PAT乙级1042 字符统计(举一反三+思想解读+逐步优化)


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

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

Python-3.12.0文档解读

目录

我的写法

优点

缺点和改进建议

时间复杂度分析

空间复杂度分析

改进后的代码

我要更强

优化方法1:使用字典

优化方法2:减少字母转换次数

优化方法3:提前退出

完整代码和注释

时间复杂度

空间复杂度

优化方法4:提前判断最大计数

哲学和编程思想

1. 使用字典而不是固定大小的列表

哲学和编程思想

2. 减少字母转换次数

哲学和编程思想

3. 提前退出

哲学和编程思想

4. 空间优化

哲学和编程思想

总结

举一反三

1. 动态分配与灵活性

2. 优化和效率

3. 贪心策略与及时决策

4. 空间时间权衡

总结



题目链接

我的写法

chars = input()  # 从用户输入获取字符串
counts = []  # 初始化一个空列表用于存储每个字符的计数

for i in range(123):  # 预先为所有ASCII值从0到122初始化计数列表
    counts.append(0)  # 将每个位置的计数初始化为0

for char in chars:  # 遍历输入字符串中的每个字符
    if char.isalpha():  # 检查字符是否是字母(a-z 或 A-Z)
        counts[ord(char.lower())] += 1  # 将字母转换为小写并增加相应位置的计数

max_count = 0  # 初始化最大计数为0
output_char = 'a'  # 初始化输出字符为'a'

for i in range(97, 123):  # 遍历小写字母的ASCII值范围(97到122,即'a'到'z')
    if counts[i] > max_count:  # 如果当前字母的计数大于当前最大计数
        max_count = counts[i]  # 更新最大计数
        output_char = chr(i)  # 更新输出字符为当前字母

print(f"{output_char} {max_count}")  # 打印出现次数最多的字母及其计数

这段代码的功能是找到用户输入字符串中出现次数最多的字母(忽略大小写)及其出现次数。以下是对这段代码的详细点评以及其时间复杂度和空间复杂度的分析:

优点

  1. 功能明确:代码的目标是清晰的,即统计字符串中每个字母的出现次数,并找出出现次数最多的字母。
  2. 兼容性:代码处理了大小写字母的情况,将所有字母转换为小写进行统一计数。
  3. 直观易懂:代码逻辑相对简单,容易理解。

缺点和改进建议

  1. 冗余初始化:初始化 counts 列表时为所有ASCII值从0到122分配空间,但实际上只需要处理字母,即范围只需97到122(小写字母a到z)。可以优化空间利用率。
  2. 代码冗长:有些地方可以简化,例如 counts 列表的初始化和检查字符是否为字母的方式。
  3. 错误处理:代码没有处理用户输入为空的情况,可能会导致意外行为。

时间复杂度分析

  • 初始化 counts 列表:这是一个固定大小的列表初始化,时间复杂度为 O(1)。
  • 字符串遍历:遍历字符串中的每个字符,时间复杂度为 O(n),其中 n 是字符串的长度。
  • 查找最大值:在固定大小(26个字母)的范围内查找最大值,时间复杂度为 O(1)。

综上所述,总的时间复杂度为 O(n),其中 n 是输入字符串的长度。

空间复杂度分析

  • counts 列表:由于该列表固定大小为123,占用的空间是固定的,空间复杂度为 O(1)。
  • 其他变量:其余变量(如 max_count、output_char)占用常数空间。

综上所述,总的空间复杂度为 O(1)。

改进后的代码

chars = input()  # 从用户输入获取字符串
counts = [0] * 26  # 初始化一个长度为26的列表用于存储字母a-z的计数

for char in chars:  # 遍历输入字符串中的每个字符
    if char.isalpha():  # 检查字符是否是字母(a-z 或 A-Z)
        counts[ord(char.lower()) - 97] += 1  # 将字母转换为小写并增加相应位置的计数

max_count = 0  # 初始化最大计数为0
output_char = 'a'  # 初始化输出字符为'a'

for i in range(26):  # 遍历字母的计数
    if counts[i] > max_count:  # 如果当前字母的计数大于当前最大计数
        max_count = counts[i]  # 更新最大计数
        output_char = chr(i + 97)  # 更新输出字符为当前字母

print(f"{output_char} {max_count}")  # 打印出现次数最多的字母及其计数

以上改进后的代码更简洁,空间利用更加合理,同时保持了总体时间复杂度和空间复杂度不变。


我要更强

虽然原始代码已经在时间复杂度上达到了 O(n) 的最佳情况,并且空间复杂度也已经很低,但是我们可以通过一些方法在合理范围内进一步优化。以下是一些可能的优化方法:

优化方法1:使用字典

使用字典而不是固定大小的列表来计数,可以动态分配空间,只为实际出现的字母分配空间。

优化方法2:减少字母转换次数

将字符转换为小写的操作可以提前完成一次,避免在循环中多次调用 char.lower()。

优化方法3:提前退出

如果我们能在遍历过程中确定最大值,并且输入数据量巨大时,理论上可以通过提前退出来减少不必要的遍历,但这个场景较为特殊,以下代码没有实现该优化。

完整代码和注释

以下是使用上述的一些优化方法的代码:

chars = input()  # 从用户输入获取字符串
counts = {}  # 使用字典初始化一个空字典用于存储字母的计数

for char in chars:  # 遍历输入字符串中的每个字符
    if char.isalpha():  # 检查字符是否是字母(a-z 或 A-Z)
        char_lower = char.lower()  # 将字母转换为小写,仅转换一次
        if char_lower in counts:  # 如果字典中已有该字母
            counts[char_lower] += 1  # 增加相应字母的计数
        else:
            counts[char_lower] = 1  # 否则初始化该字母的计数为1

max_count = 0  # 初始化最大计数为0
output_char = 'a'  # 初始化输出字符为'a'

for char, count in counts.items():  # 遍历字典中的每个字母及其计数
    if count > max_count:  # 如果当前字母的计数大于当前最大计数
        max_count = count  # 更新最大计数
        output_char = char  # 更新输出字符为当前字母

print(f"{output_char} {max_count}")  # 打印出现次数最多的字母及其计数

时间复杂度

  • 初始化字典:O(1)
  • 遍历字符串:O(n),其中 n 是字符串的长度。
  • 查找最大值:最坏情况是 O(26),但因为字母表的大小是常数,可以认为是 O(1)。

总的时间复杂度仍然是 O(n)。

空间复杂度

  • 字典:在最坏情况下,字典会包含所有26个字母,因此空间复杂度是 O(1)。

总的空间复杂度是 O(1),但相比固定大小的列表,这种方法在处理非字母字符很多的情况下会稍微节省一些空间。

优化方法4:提前判断最大计数

如果输入字符串非常大并且字母频率分布很不均匀,可以在遍历过程中通过一些启发式的方法提前判断最大计数并退出循环,但这种优化是高度特定情况的,实际意义有限,因此不进一步展示。

这些方法在合理范围内优化了代码的时间和空间复杂度,使得代码更加高效和简洁。


哲学和编程思想

在编程中,许多优化方法和编程思想与哲学理念和原则密切相关。以下是上面提到的一些优化方法及其背后的哲学和编程思想:

1. 使用字典而不是固定大小的列表

哲学和编程思想
  • 动态分配:这体现了“需要多少用多少”的思想,避免了不必要的资源分配。哲学上,这类似于“最小需求原理”(Principle of Least Demand),即只在需要的时候才分配资源。
  • 灵活性:字典提供了更大的灵活性和可扩展性,可以适应不同输入的多样性。

2. 减少字母转换次数

哲学和编程思想
  • 优化和效率:通过提前将字符转换为小写一次,减少了多次调用char.lower()的开销。这体现了“避免重复劳动”的原则。哲学上,这类似于“效率优先”(Efficiency First)的原则,即通过减少冗余操作来提高效率。
  • 最小化重复计算:编程中的一个重要思想是“避免重复计算”(Avoid Repetition),即尽量减少或消除对同一数据或操作的重复计算。

3. 提前退出

哲学和编程思想
  • 贪心策略:如果在遍历过程中能确定最大值,可以提前退出循环。这类似于贪心算法中的策略,即在每一步都做出当前最优选择,期望最终结果也是最优的。
  • 快捷处理:哲学上,这类似于“及时行乐”(Carpe Diem)或者“及时决策”的思想,即在合适的时候做出快速决策。

4. 空间优化

哲学和编程思想
  • 空间时间权衡:通过使用字典而不是固定大小的列表,能在某些情况下节省空间。这体现了“空间时间权衡”(Space-Time Tradeoff)的思想,即在某些情况下可以通过增加时间开销来节省空间,或者反过来。
  • 资源节约:哲学上,这类似于“节约主义”(Economy of Resources)的思想,即尽可能节约资源,避免浪费。

总结

这些编程思想和哲学理念在编写高效、健壮的代码时至关重要。通过理解和应用这些原则,我们不仅能够写出性能更好的代码,还能在不同情况下做出更加明智的设计决策。


举一反三

要将哲学和编程思想应用到实际编程中,并能够举一反三,以下是一些具体的技巧和方法:

1. 动态分配与灵活性

技巧:尽量使用动态数据结构(如列表、字典、集合等)来处理数据,而不是固定大小的数组。

  • 例子:如果不知道输入数据的具体大小,可以使用动态列表或字典。
  • 应用:在处理用户输入、文件数据或网络数据时,使用动态数据结构来适应变化的输入大小。

2. 优化和效率

技巧:避免不必要的重复计算或操作。提前计算并缓存结果,或者通过算法优化来减少计算量。

  • 例子:使用字典来缓存已经计算过的结果(如斐波那契数列)。
  • 应用:在多次查找操作中,可以使用哈希表来加速查找速度;在递归算法中,使用记忆化(Memoization)来保存中间结果。

3. 贪心策略与及时决策

技巧:在遍历数据时,如果可以确定某个条件立即满足,则提前退出循环或递归。

  • 例子:在寻找某个特定值时,一旦找到立即返回,避免继续不必要的遍历。
  • 应用:在搜索算法中,如二分查找、深度优先搜索(DFS)中提前判断并返回结果。

4. 空间时间权衡

技巧:在设计算法时,考虑空间和时间的权衡,选择最合适的方案。

  • 例子:对于需要频繁访问的数据,可以用更多的空间来保存中间结果,减少计算时间。
  • 应用:在动态规划中,使用辅助数组来保存结果;在大数据处理中,使用分布式计算来平衡计算速度和内存使用。

总结

通过理解和应用这些哲学和编程思想,可以在不同场景中灵活运用,写出更加高效、健壮和灵活的代码。关键在于:

  1. 评估需求:根据实际需求选择最合适的数据结构和算法。
  2. 避免冗余:尽量避免不必要的重复计算和操作。
  3. 权衡利弊:在空间和时间之间找到最佳平衡点。
  4. 灵活应变:根据输入数据的特性,灵活使用动态数据结构和提前决策策略。

这些技巧和方法不仅适用于具体问题的解决,还能培养编程中的思维方式,帮助在面对新问题时能够举一反三,找到最佳解决方案。


感谢阅读。

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

用哲学编程

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

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

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

打赏作者

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

抵扣说明:

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

余额充值