压缩字符串

021

题目描述

实现一个算法来压缩一个字符串。压缩的要求如下：

  1. 需要判断压缩能不能节省空间，仅在压缩后字符串比原字符串长度更短时进行压缩。
  2. 压缩的格式是将连续相同字符替换为字符 + 数字形式，例如 “AAABCCDDDD” 变为 “A3BC2D4″。

输入描述

输入一行字符串，长度不超过 500.

输出描述

输出一行。若输入的字符串可压缩，则输出压缩后的字符串，否则输出 NO。

输入输出样例

示例

输入

AAABCCDDDD

输出

A3BC2D4

运行限制

  • 最大运行时间：1s
  • 最大运行内存: 256M

来自: 3.压缩字符串 – 蓝桥云课

我的题解

def ya_suo_str(input_string):
    # 初始化结果字符串为空
    result = ""
    # 初始化计数器为1，用于记录连续相同字符的数量
    count = 1
    # 遍历输入字符串的所有字符，除了最后一个字符
    for i in range(len(input_string) - 1):
        # 如果当前字符和下一个字符相同，则增加计数器
        if input_string[i] == input_string[i + 1]:
            count += 1
        # 如果当前字符和下一个字符不相同，或者遍历到倒数第二个字符时（需要处理最后一个字符的情况）
        else:
            # 当计数器大于1时，将当前字符及计数器添加到结果字符串中
            if count > 1:
                result += input_string[i] + str(count)
            # 否则，仅将当前字符添加到结果字符串中
            else:
                result += input_string[i]
            # 重置计数器为1，准备处理新的字符序列
            count = 1
    # 处理最后一个字符及其对应的计数器
    if count > 1:
        result += input_string[-1] + str(count)
    # 如果最后一个字符没有被处理（即不是重复字符或单独一个字符）
    else:
        result += input_string[-1]
    
    # 判断压缩后字符串长度是否小于原字符串，若是则返回压缩后的字符串，否则返回 "NO"
    if len(result) < len(input_string):
        return result
    else:
        return "NO"

# 获取用户输入的字符串
input_str = input()
# 调用压缩函数并打印结果
print(ya_suo_str(input_str))

核心代码逻辑：

初始化结果字符串为空，计数器为1。

遍历字符串str_1的所有字符，除了最后一个字符。

如果当前字符和下一个字符相同，计数器加1。

如果计数器为1，将当前字符添加到结果字符串中，重置计数器为1。

如果计数器不为1，将当前字符和计数器的值拼接后添加到结果字符串中，重置计数器为1。

如果计数器大于1，将最后一个字符和计数器的值拼接后添加到结果字符串中。

如果计数器不大于1，将最后一个字符添加到结果字符串中。

如果结果字符串的长度小于原字符串的长度，返回结果字符串。

如果结果字符串的长度大于等于原字符串的长度，返回”NO”。

AI 题解

通义灵码

def compress_string(input_string):
    compressed_string = ""
    count = 1

    # 遍历输入字符串的每个字符
    for i in range(len(input_string)):
        if i == len(input_string) - 1 or input_string[i] != input_string[i + 1]:
            # 当遍历到字符串末尾或当前字符与下一个字符不相同时
            compressed_string += input_string[i] + str(count)
            count = 1
        else:
            # 当前字符与下一个字符相同，计数器加1
            count += 1

    # 检查压缩后的字符串长度是否小于原字符串长度
    if len(compressed_string) < len(input_string):
        return compressed_string
    else:
        return input_string

# 示例
input_str = "AAABCCDDDD"
print(compress_string(input_str))  # 输出: "A3B1C2D4"

发现代码有问题，即统计的连续字符只有一个的时候，输出依旧带有“字符 1”，所以我修改了一下，以下是正确的代码：

def compress_string(input_string):
    compressed_string = ""
    count = 1

    # 遍历输入字符串的每个字符
    for i in range(len(input_string)):
        if i == len(input_string) - 1 or input_string[i] != input_string[i + 1]:
            if count == 1:
                compressed_string += input_string[i]
                count = 1
                continue
            # 当遍历到字符串末尾或当前字符与下一个字符不相同时
            compressed_string += input_string[i] + str(count)
            count = 1
        else:
            # 当前字符与下一个字符相同，计数器加1
            count += 1

    # 检查压缩后的字符串长度是否小于原字符串长度
    if len(compressed_string) < len(input_string):
        return compressed_string
    else:
        return input_string

# 示例
input_str = "AAABCCDDDD"
print(compress_string(input_str))  # 输出: "A3BC2D4"

qwen-max-longcontext

为了实现这个字符串压缩算法，我们可以按照以下步骤编写一个Python函数：

def compress_string(s):
    # 初始化结果字符串和计数器
    result = ''
    count = 1

    # 遍历输入字符串
    for i in range(1, len(s)):
        # 如果当前字符与前一个字符相同，则增加计数器
        if s[i] == s[i - 1]:
            count += 1
        else:
            # 否则，将前一个字符及其重复次数添加到结果字符串中
            result += s[i - 1] + str(count)
            # 重置计数器为1，开始计算新的连续字符
            count = 1

    # 处理最后一个字符序列（可能没有遇到不同的字符）
    result += s[-1] + str(count)

    # 判断压缩后字符串长度是否小于原字符串，若不是则返回原字符串
    if len(result) >= len(s):
        return s
    else:
        return result

# 示例测试
s = "AAABCCDDDD"
compressed_s = compress_string(s)
print(compressed_s)  # 输出: "A3B2C2D4"

这个算法会根据给定的规则压缩字符串，并在压缩后的字符串比原字符串更短时返回压缩后的字符串。如果压缩后不节省空间，则返回原始字符串。

我发现这代码有问题，依旧是输出的时候连续字符只有一个的情况下，输出还是“字符 1”，所以需要稍加修改：

def compress_string(s):
    # 初始化结果字符串和计数器
    result = ''
    count = 1

    # 遍历输入字符串
    for i in range(1, len(s)):
        # 如果当前字符与前一个字符相同，则增加计数器
        if s[i] == s[i - 1]:
            count += 1
        else:
            if count == 1:
                result += s[i-1]
                count = 1
                continue
            # 否则，将前一个字符及其重复次数添加到结果字符串中
            result += s[i - 1] + str(count)
            # 重置计数器为1，开始计算新的连续字符
            count = 1

    # 处理最后一个字符序列（可能没有遇到不同的字符）
    result += s[-1] + str(count)

    # 判断压缩后字符串长度是否小于原字符串，若不是则返回原字符串
    if len(result) >= len(s):
        return s
    else:
        return result

# 示例测试
s = "AAABCCDDDD"
compressed_s = compress_string(s)
print(compressed_s)  # 输出: "A3BC2D4"

qwen-max

def compress_string(s):
    if len(s) <= 1:
        return s

    compressed = ''
    count = 1
    prev_char = s[0]

    for char in s[1:]:
        if char == prev_char:
            count += 1
        else:
            compressed += prev_char + str(count)
            prev_char = char
            count = 1

    # 添加最后一个字符及其重复次数
    compressed += prev_char + str(count)

    # 比较压缩后的字符串长度，如果比原字符串长，则返回原字符串
    if len(compressed) >= len(s):
        return s
    else:
        return compressed


# 示例
s = "AAABCCDDDD"
print(compress_string(s))  # 输出: A3BC2D4

这个算法首先遍历输入字符串 s，统计连续相同字符的数量，并将它们以字符加数字的形式添加到压缩字符串 compressed 中。在遍历结束后，会检查压缩字符串的长度是否小于原始字符串的长度，如果是，则返回压缩后的字符串；否则，返回原始字符串。

我发现这个代码和上面的一样有问题，所以修改了一下：

def compress_string(s):
    if len(s) <= 1:
        return s

    compressed = ''
    count = 1
    prev_char = s[0]

    for char in s[1:]:
        if char == prev_char:
            count += 1
        else:
            if count == 1:
                compressed += prev_char
                prev_char = char
                count = 1
                continue
            compressed += prev_char + str(count)
            prev_char = char
            count = 1

    # 添加最后一个字符及其重复次数
    compressed += prev_char + str(count)

    # 比较压缩后的字符串长度，如果比原字符串长，则返回原字符串
    if len(compressed) >= len(s):
        return s
    else:
        return compressed


# 示例
s = "AAABCCDDDD"
print(compress_string(s))  # 输出: A3BC2D4

ChatGLM-Turbo

ERNIE-Bot-4.0

这是一个字符串压缩的问题，我们可以使用Python来实现这个算法。首先，我们需要遍历字符串，找到连续相同的字符并计算它们的数量，然后将字符和数量拼接成新的字符串。最后，我们比较新字符串和原字符串的长度，如果新字符串更短，则返回新字符串，否则返回原字符串。

以下是一个可能的Python实现：

def compress_string(s):
    if not s:
        return s

    compressed = []
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i-1]:
            count += 1
        else:
            compressed.append(s[i-1] + str(count) if count > 1 else s[i-1])
            count = 1
    
    compressed.append(s[-1] + str(count) if count > 1 else s[-1])
    
    compressed_str = ''.join(compressed)
    return compressed_str if len(compressed_str) < len(s) else s

# 测试
s = "AAABCCDDDD"
print(compress_string(s))  # 输出：A3BC2D4

注意，上面的代码有一个小错误：在for循环的末尾，我们需要在添加最后一个字符之前检查它是否与前一个字符相同。为了解决这个问题，我们可以在循环结束后添加一个特殊的处理步骤来处理最后一个字符。

这是修复后的代码：

def compress_string(s):
    if not s:
        return s

    compressed = []
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i-1]:
            count += 1
        else:
            compressed.append(s[i-1] + str(count) if count > 1 else s[i-1])
            count = 1
            
    # 处理最后一个字符
    compressed.append(s[-1] + str(count) if count > 1 else s[-1])
    
    compressed_str = ''.join(compressed)
    return compressed_str if len(compressed_str) < len(s) else s

# 测试
s = "AAABCCDDDD"
print(compress_string(s))  # 输出：A3BC2D4

现在，代码应该可以正确地压缩字符串了。

讯飞星火 V3.0

好的，以下是按照您的要求实现的字符串压缩算法：

def compress_string(s: str) -> str:
    """
    压缩字符串。如果压缩后的长度不小于原字符串长度，则返回原字符串。
    压缩格式为：连续相同字符替换为字符+数字形式，例如 "AAABCCDDDD" 变为 "A3BC2D4"。
    
    参数：
        s (str): 待压缩的字符串
        
    返回：
        str: 压缩后的字符串或原字符串
    """
    if not s:
        return ""

    compressed = []
    count = 1
    prev_char = s[0]

    for char in s[1:]:
        if char == prev_char:
            count += 1
        else:
            compressed.append(prev_char)
            if count > 1:
                compressed.append(str(count))
            prev_char = char
            count = 1

    compressed.append(prev_char)
    if count > 1:
        compressed.append(str(count))

    compressed_str = ''.join(compressed)
    
    # 判断是否节省空间
    if len(compressed_str) >= len(s):
        return s
    return compressed_str

# 测试代码
test_str = "AAABCCDDDD"
print(compress_string(test_str))  # 输出： A3BC2D4

这个函数首先初始化一个空列表 compressed 来存储压缩后的字符和数字。它遍历输入字符串 s，计算每个字符的连续出现次数，并将字符及其出现次数添加到 compressed 列表中。最后，它将 compressed 列表转换为字符串并返回。如果压缩后的字符串不比原字符串短，则直接返回原字符串。

豆包

以下是一个使用 Python 实现字符串压缩算法的示例代码：

def compress_string(s):
    result = []
    count = 1
    for i in range(1, len(s)):
        if s[i] == s[i - 1]:
            count += 1
        else:
            if count > 1:
                result.append(s[i - 1])
                result.append(str(count))
            else:
                result.append(s[i - 1])
            count = 1
    if count > 1:
        result.append(s[-1])
        result.append(str(count))
    return ''.join(result)

# 测试示例
s = "AAABCCDDDD"
compressed_s = compress_string(s)
print("原始字符串:", s)
print("压缩后字符串:", compressed_s)

在上述代码中，compress_string 函数接受一个字符串 s 作为输入，并返回压缩后的字符串。函数使用一个列表 result 来存储压缩后的字符。

通过遍历输入字符串 s，如果当前字符与前一个字符相同，则计数器 count 加 1；否则，如果计数器大于 1，则将前一个字符和计数器值添加到结果列表中，并将计数器重置为 1。最后，如果在遍历完字符串后计数器仍大于 1，则将最后一个字符和计数器值添加到结果列表中。

这样，最终的结果列表 result 中就包含了压缩后的字符。通过 ''.join(result) 将列表中的字符连接成一个字符串，并返回压缩后的字符串。

你可以根据需要修改和扩展这个算法，以满足具体的压缩要求。希望这个示例对你有帮助！如果还有其他问题，请随时提问。

MiniMax-abab6-chat

下面是一个使用Python实现的简单字符串压缩算法，该算法遵循您提出的压缩规则：

def compress_string(s):
    # 空字符串或单个字符的字符串不需要压缩
    if len(s) <= 1:
        return s
    
    # 初始化压缩后的字符串和计数器
    compressed = []
    count = 1
    
    # 遍历字符串中的每个字符
    for i in range(1, len(s)):
        # 如果当前字符与前一个字符相同，增加计数器
        if s[i] == s[i - 1]:
            count += 1
        else:
            # 如果当前字符与前一个字符不同，添加压缩后的字符到压缩字符串
            compressed.append(s[i - 1] + (str(count) if count > 1 else ''))
            count = 1  # 重置计数器
    
    # 添加最后一个字符及其计数
    compressed.append(s[-1] + (str(count) if count > 1 else ''))
    
    # 连接压缩后的字符并返回
    return ''.join(compressed)

# 测试算法
original_string = "AAABCCDDDD"
compressed_string = compress_string(original_string)
print(f"Original string: {original_string}")
print(f"Compressed string: {compressed_string}")

这个函数compress_string接收一个字符串s作为输入，然后按照您描述的规则进行压缩。如果压缩后的字符串比原字符串短，它会返回压缩后的字符串；否则，它会返回原字符串。

请注意，这个算法在压缩后的字符串长度与原字符串长度相同的情况下，会返回原字符串。您可以根据需要调整这个行为，例如，可以选择返回压缩后的字符串，即使它不比原字符串短。

天工 AI 搜索

def compress(s):
    # 如果字符串长度小于或等于1，则无法压缩
    if len(s) <= 1:
        return s
    
    # 初始化结果字符串和计数器
    compressed = []
    count = 1
    
    # 遍历字符串
    for i in range(len(s) - 1):
        if s[i] == s[i + 1]:
            count += 1
        else:
            compressed.append(s[i])
            if count > 1:
                compressed.append(str(count))
            count = 1
    
    # 添加最后一个字符和它的计数
    compressed.append(s[-1])
    if count > 1:
        compressed.append(str(count))
    
    # 将列表转换回字符串
    return ''.join(compressed)

# 示例
original_string = "AAABCCDDDD"
compressed_string = compress(original_string)
print("Original:", original_string)
print("Compressed:", compressed_string)

此脚本定义了一个compress函数，该函数接受一个字符串s作为输入，然后按照上述压缩规则进行处理。如果压缩后的字符串长度更短，它会返回压缩后的字符串；否则，返回原字符串。最后，提供了一个示例来展示如何使用这个函数。

Kimi.ai

下面是一个Python函数，用于实现上述要求的字符串压缩算法：

def compress_string(s):
    # 初始化压缩后的字符串和计数器
    compressed = []
    count = 1

    # 遍历字符串中的每个字符
    for i in range(1, len(s)):
        # 如果当前字符与前一个字符相同，增加计数
        if s[i] == s[i - 1]:
            count += 1
        else:
            # 如果当前字符不同，将前一个字符及其计数添加到压缩字符串中
            if count > 1:
                compressed.append(s[i - 1] + str(count))
            else:
                compressed.append(s[i - 1])
            # 重置计数器并继续
            count = 1

    # 处理最后一个字符
    if count > 1:
        compressed.append(s[-1] + str(count))
    else:
        compressed.append(s[-1])

    # 将压缩后的字符串列表转换为字符串
    compressed_str = ''.join(compressed)

    # 如果压缩后的字符串比原字符串短，则返回压缩后的字符串，否则返回原字符串
    return compressed_str if len(compressed_str) < len(s) else s

# 示例使用
original_string = "AAABCCDDDD"
compressed_string = compress_string(original_string)
print(compressed_string)  # 输出: "A3BC2D4"

这个函数首先初始化一个空列表来存储压缩后的字符串，以及一个计数器来记录连续字符的数量。然后，它遍历输入字符串的每个字符，如果当前字符与前一个字符相同，计数器增加；如果不同，将前一个字符及其计数（如果大于1）添加到压缩字符串列表中，并重置计数器。最后，处理最后一个字符，并将其添加到压缩字符串列表中。函数返回压缩后的字符串，但如果压缩后的字符串长度没有减少，则返回原始字符串。

存档地址：https://www.yuque.com/worthstudy/study/rthk1tdeustygcei?singleDoc# 《压缩字符串》

© 版权声明
文章版权归作者所有，如需转载请联系作者。若文章内容侵犯了您的权益，请通过网站底部联系方式联系我们处理（本站具有最终解释权）。如有不便之处，敬请谅解。
THE END
PythonPythonPythonPythonPython专业专业后端后端后端大学大学学习栏目技术教程竞赛竞赛算法算法算法编程编程蓝桥杯蓝桥杯计算机计算机计算机题库
# Python# 蓝桥杯# 算法# 字符串处理# 字符串压缩
喜欢就点赞支持一下吧，如果觉得不错或日后有所需要，可以收藏文章和关注作者哦。
点赞1打赏 分享
评论 抢沙发

请登录后发表评论

    暂无评论内容

最近一周热门文章推荐

1信息收集成瘾特征（）

2互联网是人们从事获取知识、了解时事、交流感情、查询信息等的重要途径？

友情链接
LoveWall表白墙值得研究网址导航现科信息安全协会