青训营X豆包MarsCode ｜ 豆包MarsCode AI 刷题-递归与迭代的应用

用户25181781130
39 阅读6分钟

递归与迭代的运用

题目如下：

小D拿到了一个仅由 "abc" 三种字母组成的字符串。她每次操作会对所有字符同时进行以下变换： 将 'a' 变成 'bc' 将 'b' 变成 'ca' 将 'c' 变成 'ab' 小D将重复该操作 k 次。你的任务是输出经过 k 次变换后，得到的最终字符串。 例如：对于初始字符串 "abc"，执行 2 次操作后，字符串将变为 "caababbcbcca"。 测试样例 样例1： 输入：s = "abc", k = 2 输出：'caababbcbcca' 样例2： 输入：s = "abca", k = 3 输出：'abbcbccabccacaabcaababbcabbcbcca' 样例3： 输入：s = "cba", k = 1 输出：'abcabc'

思路：

使用递归或迭代的方法来解决这个问题。每次操作会对所有字符同时进行变换，因此我们需要在每次操作中生成新的字符串，然后继续进行下一次操作，直到完成 k 次操作。

  1. 定义变换规则：将 'a' 变成 'bc'，将 'b' 变成 'ca'，将 'c' 变成 'ab'。
  2. 迭代变换：使用一个循环来执行 k 次变换，每次生成新的字符串。
  3. 返回最终结果：经过 k 次变换后，返回最终的字符串。

代码如下

def solution(s: str, k: int) -> str:

# 定义变换规则
transform_rules = {
    'a': 'bc',
    'b': 'ca',
    'c': 'ab'
}

# 迭代执行 k 次变换
for _ in range(k):
    new_s = ''.join(transform_rules[char] for char in s)
    s = new_s

return s

测试样例

if name == "main": # 样例1 s1 = "abc" k1 = 2 print(transform_string(s1, k1)) # 输出：'caababbcbcca'

# 样例2
s2 = "abca"
k2 = 3
print(transform_string(s2, k2))  # 输出：'abbcbccabccacaabcaababbcabbcbcca'

# 样例3
s3 = "cba"
k3 = 1
print(transform_string(s3, k3))  # 输出：'abcabc'# write code here

代码解释

  1. 定义变换规则：

    • 使用字典 transform_rules 来定义每个字符的变换规则。
    • 'a' 变成 'bc'
    • 'b' 变成 'ca'
    • 'c' 变成 'ab'

  2. 迭代变换：

    • 使用 for 循环执行 k 次变换。
    • 在每次变换中，使用列表推导式和 join 方法生成新的字符串 new_s，其中每个字符都根据 transform_rules 进行变换。
    • 将生成的新字符串 new_s 赋值给 s，以便在下一次迭代中继续变换。

  3. 返回最终结果：

    • 经过 k 次变换后，返回最终的字符串 s。

测试样例

  1. 样例1：

    • 输入：s = "abc", k = 2
    • 输出：'caababbcbcca'
    • 解释：第一次变换后，"abc" 变成 "bccaab"；第二次变换后，"bccaab" 变成 "caababbcbcca"。

  2. 样例2：

    • 输入：s = "abca", k = 3
    • 输出：'abbcbccabccacaabcaababbcabbcbcca'
    • 解释：经过三次变换后，字符串逐渐变长，最终结果为 'abbcbccabccacaabcaababbcabbcbcca'。

  3. 样例3：

    • 输入：s = "cba", k = 1
    • 输出：'abcabc'
    • 解释：第一次变换后，"cba" 变成 "abcabc"。

测试样例解释

样例1

  • 输入：s = "abc", k = 2

  • 输出：'caababbcbcca'

  • 解释：

    • 第一次变换后，"abc" 变成 "bccaab"：

      • 'a' 变成 'bc'
      • 'b' 变成 'ca'
      • 'c' 变成 'ab'

    • 第二次变换后，"bccaab" 变成 "caababbcbcca"：

      • 'b' 变成 'ca'
      • 'c' 变成 'ab'
      • 'c' 变成 'ab'
      • 'a' 变成 'bc'
      • 'a' 变成 'bc'
      • 'b' 变成 'ca'
样例2

  • 输入：s = "abca", k = 3

  • 输出：'abbcbccabccacaabcaababbcabbcbcca'

  • 解释：

    • 第一次变换后，"abca" 变成 "bccaabbc"：

      • 'a' 变成 'bc'
      • 'b' 变成 'ca'
      • 'c' 变成 'ab'
      • 'a' 变成 'bc'

    • 第二次变换后，"bccaabbc" 变成 "caababbcbccabccabcaabbc"：

      • 'b' 变成 'ca'
      • 'c' 变成 'ab'
      • 'c' 变成 'ab'
      • 'a' 变成 'bc'
      • 'a' 变成 'bc'
      • 'b' 变成 'ca'
      • 'b' 变成 'ca'
      • 'c' 变成 'ab'

    • 第三次变换后，"caababbcbccabccabcaabbc" 变成 "abbcbccabccacaabcaababbcabbcbcca"：

      • 每个字符按照 transform_rules 进行变换
样例3

  • 输入：s = "cba", k = 1

  • 输出：'abcabc'

  • 解释：

    • 第一次变换后，"cba" 变成 "abcabc"：

      • 'c' 变成 'ab'
      • 'b' 变成 'ca'
      • 'a' 变成 'bc'

递归

定义

递归是一种编程技术，其中一个函数在其定义中调用自身。递归通常涉及将问题分解成更小的子问题，直到达到基本情况（即不再递归的终止条件）。

优点
  1. 代码简洁：递归代码通常比迭代代码更简洁，更容易理解和编写。
  2. 自然表达：对于某些问题（如树和图的遍历），递归是自然且直观的解决方案。
缺点
  1. 内存消耗：每次递归调用都会在调用栈中占用一定的内存，可能导致栈溢出。
  2. 性能问题：递归调用的开销较大，尤其是对于深度递归，可能会导致性能下降。
示例

计算阶乘的递归实现：

python
深色版本
def factorial_recursive(n):
    if n == 0:
        return 1
    else:
        return n * factorial_recursive(n - 1)

迭代

定义

迭代是一种通过循环结构重复执行某段代码的编程技术。迭代通常使用 for 或 while 循环来实现。

优点
  1. 内存效率：迭代通常比递归更节省内存，因为不需要在调用栈中保存大量的函数调用。
  2. 性能：迭代通常比递归更快，因为没有函数调用的开销。
缺点
  1. 代码复杂：对于某些问题，迭代代码可能比递归代码更复杂，更难理解和编写。
  2. 不自然：对于某些问题，迭代可能不是最自然的解决方案。
示例

计算阶乘的迭代实现：

python
深色版本
def factorial_iterative(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

选择递归还是迭代

选择递归的情况
  1. 问题天然适合递归：例如，树和图的遍历、分治算法（如快速排序、归并排序）等。
  2. 代码简洁优先：如果代码的简洁性和可读性更重要，递归可能是更好的选择。
  3. 问题规模较小：如果问题的规模较小，递归的内存消耗和性能问题可以忽略不计。
选择迭代的情况
  1. 性能和内存效率优先：如果性能和内存效率是关键因素，迭代通常是更好的选择。
  2. 问题规模较大：对于大规模问题，递归可能导致栈溢出，迭代更安全。
  3. 问题复杂度较高：对于复杂的逻辑，迭代可能更容易理解和调试。

综合示例

递归示例：斐波那契数列
python
深色版本
def fibonacci_recursive(n):
    if n <= 1:
        return n
    else:
        return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)
迭代示例：斐波那契数列
python
深色版本
def fibonacci_iterative(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

结论

递归和迭代各有优缺点，选择哪种方法取决于具体的问题和上下文。对于某些问题，递归可能是更自然和简洁的解决方案，而对于其他问题，迭代可能更高效和安全。

avatar
文章
阅读
粉丝