问题描述
给定一个字符串S，需要将字符串中所有的小写字母'a'替换为"%100"。这是一个基础的字符串替换问题，需要返回替换后的新字符串。
解题思路
这个问题可以通过以下几种方式解决：
-
直接使用字符串的replace方法：
- Python的字符串提供了内置的replace方法，可以直接完成替换
- 这是最简单和最直观的解决方案
-
遍历字符串方式：
- 逐个检查字符串中的每个字符
- 遇到'a'时追加"%100"，否则追加原字符
- 使用列表存储结果并最终合并
代码实现
def solution(s: str) -> str:
return s.replace('a', '%100')
if __name__ == '__main__':
print(solution(s="abcdwa") == '%100bcdw%100')
print(solution(s="banana") == 'b%100n%100n%100')
print(solution(s="apple") == '%100pple')
示例分析
样例1:
- 输入：s = "abcdwa"
- 输出："%100bcdw%100"
- 分析：字符串中有两个'a'，都被替换为"%100"
样例2:
- 输入：s = "banana"
- 输出："b%100n%100n%100"
- 分析：字符串中有三个'a'，每个都被替换为"%100"
样例3:
- 输入：s = "apple"
- 输出："%100pple"
- 分析：字符串开头的'a'被替换为"%100"
复杂度分析
使用replace方法：
- 时间复杂度：O(n)，其中n是字符串长度
- 空间复杂度：O(n)，需要存储新的字符串
使用遍历方法：
- 时间复杂度：O(n)，需要遍历整个字符串
- 空间复杂度：O(n)，在最坏情况下（全是'a'）会扩展为原来的多倍
扩展思考
- 如果需要替换多个不同的字符怎么处理？
- 如果替换的目标字符串长度不固定怎么处理？
- 在内存受限的情况下，如何优化空间使用？
1. 替换多个不同字符的处理方案
方案一：使用多次replace
def multi_replace(s: str) -> str:
replacements = {
'a': '%100',
'b': '%200',
'c': '%300'
}
for old, new in replacements.items():
s = s.replace(old, new)
return s
方案二：使用正则表达式
import re
def multi_replace_regex(s: str) -> str:
replacements = {
'a': '%100',
'b': '%200',
'c': '%300'
}
pattern = '|'.join(map(re.escape, replacements.keys()))
return re.sub(pattern, lambda m: replacements[m.group()], s)
2. 处理可变长度替换字符串的方案
动态替换方案
def dynamic_replace(s: str, replacements: dict) -> str:
result = []
i = 0
while i < len(s):
replaced = False
# 检查从当前位置开始的所有可能匹配
for key, value in sorted(replacements.items(), key=lambda x: len(x[0]), reverse=True):
if s[i:].startswith(key):
result.append(value)
i += len(key)
replaced = True
break
if not replaced:
result.append(s[i])
i += 1
return ''.join(result)
# 使用示例
replacements = {
'a': '%100',
'ab': '%200',
'abc': '%300'
}
print(dynamic_replace("abcdef", replacements)) # 优先匹配最长的模式
3. 内存优化方案
方案一：使用生成器
def memory_efficient_replace(s: str) -> str:
def char_generator():
for char in s:
if char == 'a':
yield '%100'
else:
yield char
return ''.join(char_generator())
方案二：分块处理
def chunk_replace(s: str, chunk_size: int = 1024) -> str:
result = []
for i in range(0, len(s), chunk_size):
chunk = s[i:i + chunk_size]
processed_chunk = chunk.replace('a', '%100')
result.append(processed_chunk)
return ''.join(result)
方案三：原地替换（适用于可变字符串）
def in_place_replace(chars: list) -> None:
"""
假设输入是字符列表而不是字符串
这种方法适用于类似LeetCode这样的原地修改要求
"""
i = 0
while i < len(chars):
if chars[i] == 'a':
# 为要插入的新字符腾出空间
chars[i:i] = list('%100')
i += 4 # 跳过插入的新字符
else:
i += 1
性能比较
各方案的性能对比：
-
单次replace：
- 优点：代码简单，内置函数效率高
- 缺点：不适合复杂的替换规则
-
正则表达式：
- 优点：灵活性强，可以处理复杂模式
- 缺点：对于简单替换来说开销较大
-
生成器方案：
- 优点：内存占用小，适合处理大文件
- 缺点：总体处理时间可能较长
-
分块处理：
- 优点：平衡了内存使用和处理效率
- 缺点：需要合理设置块大小
使用建议
- 对于简单的单字符替换，使用基础的replace方法
- 对于需要处理大文件的情况，使用生成器或分块处理方案
- 对于复杂的替换规则，使用正则表达式方案
- 对于内存敏感的场景，优先考虑分块处理或生成器方案
