38. 外观数列 - 力扣(LeetCode)

基础知识要求：

Java：方法、for循环、if eles语句、StringBuilder类

Python： 方法、for循环、if else语句、字符串拼接

题目： 

「外观数列」是一个数位字符串序列，由递归公式定义：

• countAndSay(1) = "1"
• countAndSay(n) 是 countAndSay(n-1) 的行程长度编码。

行程长度编码（RLE）是一种字符串压缩方法，其工作原理是通过将连续相同字符（重复两次或更多次）替换为字符重复次数（运行长度）和字符的串联。例如，要压缩字符串 "3322251" ，我们将 "33" 用 "23" 替换，将 "222" 用 "32" 替换，将 "5" 用 "15" 替换并将 "1" 用 "11" 替换。因此压缩后字符串变为 "23321511"。

给定一个整数 n ，返回 外观数列 的第 n 个元素。

示例 1：

输入：n = 4

输出："1211"

解释：

countAndSay(1) = "1"

countAndSay(2) = "1" 的行程长度编码 = "11"

countAndSay(3) = "11" 的行程长度编码 = "21"

countAndSay(4) = "21" 的行程长度编码 = "1211"

示例 2：

输入：n = 1

输出："1"

解释：

这是基本情况。

提示：

• 1 <= n <= 30

思路解析：

1. 理解问题：
   • 首先，理解外观数列的定义。它从一个单独的字符 "1" 开始，后续每一项都是对前一项的行程长度编码（RLE）。
   • 行程长度编码（RLE）是将连续的相同字符替换为它们出现的次数和该字符的串联。
2. 初始化：
   • 对于基本情况，即 n = 1，直接返回字符串 "1"。
   • 对于其他情况，我们需要一个循环来迭代地从 n = 2 构建到 n。
3. 迭代构建：
   • 在循环中，我们需要两个变量：一个是 prev（存储前一项的外观数列），初始化为 "1"；另一个是 curr（存储当前项的外观数列），初始化为空字符串。
   • 还需要一个变量 count 来跟踪 prev 中连续相同字符的数量，初始化为 1。
   • 遍历 prev 字符串，每次迭代时检查当前字符与前一个字符是否相同。如果相同，count 加 1；如果不同，将 count 和前一个字符添加到 curr 中，并重置 count 为 1。
   • 在遍历完 prev 后，别忘了处理最后一个字符的计数，因为循环中可能没有捕获到它。
   • 最后，将 curr 设置为新的 prev，以便下一次迭代。
4. 返回结果：
   • 当循环结束时，prev 将包含外观数列的第 n 个元素。
   • 返回 prev 即可。
5. 编写代码：
   • 根据上述思路，编写代码实现外观数列的生成。

这样，我们就可以通过迭代的方式构建出外观数列，并返回第 n 个元素。

Java代码示例：

public class CountAndSay {  
    public String countAndSay(int n) {  
        if (n == 1) {  
            return "1";  
        }  
  
        String prev = "1"; // 外观数列的前一项  
        for (int i = 2; i <= n; i++) {  
            StringBuilder curr = new StringBuilder(); // 当前项，使用StringBuilder更高效  
            int count = 1; // 连续字符的计数  
  
            // 遍历前一项字符串  
            for (int j = 1; j < prev.length(); j++) {  
                if (prev.charAt(j) == prev.charAt(j - 1)) {  
                    count++; // 连续字符，计数加1  
                } else {  
                    // 字符不连续，将前一个字符的计数和字符本身添加到当前项中  
                    curr.append(count).append(prev.charAt(j - 1));  
                    count = 1; // 重置计数  
                }  
            }  
  
            // 处理最后一个字符的计数  
            curr.append(count).append(prev.charAt(prev.length() - 1));  
  
            // 更新前一项为当前项  
            prev = curr.toString();  
        }  
  
        // 返回外观数列的第n个元素  
        return prev;  
    }  
  
    public static void main(String[] args) {  
        CountAndSay solution = new CountAndSay();  
        System.out.println(solution.countAndSay(4)); // 输出: 1211  
        System.out.println(solution.countAndSay(1)); // 输出: 1  
    }  
}

Python代码示例：

def countAndSay(n: int) -> str:  
    if n == 1:  
        return "1"  
      
    prev = "1"  # 初始化prev为外观数列的第一个元素  
    for i in range(2, n + 1):  
        curr = ""  # 用于构建当前外观数列元素的字符串  
        count = 1  # 初始化计数为1，用于计算连续字符的数量  
          
        # 遍历prev字符串，统计连续字符的数量并构建curr字符串  
        for j in range(1, len(prev)):  
            if prev[j] == prev[j - 1]:  
                count += 1  
            else:  
                curr += str(count) + prev[j - 1]  # 将前一个字符的计数和字符本身添加到curr中  
                count = 1  # 重置计数  
          
        # 处理最后一个字符的计数  
        curr += str(count) + prev[-1]  
          
        # 更新prev为curr，以便下一次迭代  
        prev = curr  
      
    return prev  
  
# 示例  
print(countAndSay(4))  # 输出: "1211"  
print(countAndSay(1))  # 输出: "1"