蓝桥杯Python数组和字符串部分题目总结

蓝桥杯Python题目整理—数组和字符串部分

以下所有题目选自蓝桥云课：Python百题大冲关（https://www.lanqiao.cn/courses/5456）

1. 确定字符串是否包含唯一字符

挑战介绍

实现一个算法来识别一个字符串的字符是否是唯一的。

挑战内容

本次挑战中，你需要在 unique_chars.py 文件中补充函数 has_unique_chars 的空缺部分。

• has_unique_chars 函数接受一个参数，string 用于指定传入的字符串;
• has_unique_chars 函数输出一个布尔值，即 True 或者 False。

你需要补充 has_unique_chars 函数，使其可以识别传入的 string 字符串的字符是否是唯一的，即有没有重复的字符。要求如下：

• 如果传入字符串的字符是唯一的，则返回 True；
• 如果传入字符串的字符是有重复的，则返回 False；
• 如果传入的字符串为 None，也返回 False。

挑战要求

• 代码必须写入 unique_chars.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 unique_chars.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决字符串中字符的唯一性问题，可以很自然的联想到Python中用set集合来去重的方法，用去重后集合的长度len和之前的字符串长度做对比。若不一致则说明字符有重复，返回False，反之返回True。

解决方案

class UniqueChars(object):

    def has_unique_chars(self, string):

        ### 补充代码 ###
        if string is None:
            return False
        elif len(set(string)) == len(string):
            return True
        elif len(set(string)) != len(string):
            return False

2. 确定字符串是否是另一个的排列

挑战介绍

实现一个算法来识别一个字符串 str2 是否是另一个字符串 str1 的排列。排列的解释如下：

• 如果将 str1 的字符拆分开，重新排列后再拼接起来，能够得到 str2 ，那么就说字符串 str2 是字符串 str1 的排列。

挑战内容

• 本次挑战中，你需要在 permutation.py 文件中补充函数 is_permutation 的空缺部分。

  • is_permutation 函数接受两个参数，str1，str2 用于指定传入的两个字符串;
  • is_permutation 函数输出一个布尔值，即 True 或者 False。

  你需要补充 is_permutation 函数，使其可以识别 str2 字符串是否是 str1 字符串的排列。要求如下：

  • 如果 str2 字符串是 str1 字符串的排列，则返回 True；
  • 如果 str2 字符串不是 str1 字符串的排列，则返回 False；
  • 如果传入的字符串有 None，或者有空字符串，则返回 False。

挑战要求

• 代码必须写入 permutation.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 permutation.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决的关键问题是重新排列的问题，我们可以将两个字符串均进行列表化，然后进行列表默认排序。排序后得到的两个列表如果相同，则说明一者经过重新排列后可以得到另一者（则第一个字符串为另一个字符串的排列），反之则不可以。注意：此处与字符的重复性有关，所以不能采用set去重的方法进行对比。

解决方案

class Permutations(object):

    def is_permutation(self, str1, str2):

        ### 补充代码 ###
        #判断传入字符串是否有None
        if (str1 is None) or (str2 is None):
            return False
        #字符串列表化，进行统一排序
        str1_list = list(str1)
        str1_list.sort()
        str2_list = list(str2)
        str2_list.sort()
        #对比排序后的列表
        if str1_list == str2_list:
            return True
        else:
            return False

3. 确定字符串是否是另一个的旋转

挑战介绍

实现一个算法来识别一个字符串 s2 是否是另一个字符串 s1 的旋转。旋转的解释如下：

• 如果将 s1 从某个位置断开，拆分成两个字符串（可能有一个为空字符串），再将这两个字符串调换顺序后拼接起来，能够得到 s2 ，那么说字符串 s2 是字符串 s1 的旋转。

挑战内容

本次挑战中，你需要在 rotation.py 文件中补充函数 is_substring 及函数 is_rotation 的空缺部分。

• is_substring 函数接受两个参数，s1，s2 用于指定传入的两个字符串;
• is_substring 函数由于判断传入的一个字符串是否是另一个的子字符串，它需要返回一个布尔值。
• is_rotation 函数接受两个参数，s1，s2 用于指定传入的两个字符串;
• is_rotation 函数需调用 is_substring 函数，但仅可调用一次;
• is_rotation 函数输出一个布尔值，即 True 或者 False。

你需要补充 is_substring 函数及 is_rotation 函数，使 is_rotation 函数可以识别传入的 s2 字符串是否是 s1 字符串的旋转。要求如下：

• 如果 s2 字符串是 s1 字符串的旋转，则返回 True；
• 如果 s2 字符串不是 s1 字符串的旋转，则返回 False；
• 如果传入的字符串有一个是 None 或者空字符，但另外一个不是时，也返回 False。

挑战要求

• 代码必须写入 rotation.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 rotation.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决的关键问题是旋转，此处可以将旋转的思维简化，对于一个字符串而言，无论怎么旋转，得到的结果一定在其重复两次得到的字符串中。举一个例子：对于“abc"，无论按照旋转规则如何旋转，得到的字符串均在”abcabc“中。

解决方案

#coding:utf-8
class Rotation(object):

    def is_substring(self, s1, s2):

        ### 补充代码 ###
        return (s1 in s2)

    def is_rotation(self, s1, s2):

        ### 补充代码 ###
        ### 仅仅调用一次 is_substring 函数 ###
        #判断传入字符串是否为空，传入字符传中有一个是空，返回False
        if (s1 is None) or (s2 is None):
            return False
        #如果传入两个字符串长度不相同，返回False
        if len(s1) != len(s2):
            return False
        #将s1进行二次重复
        s3 = s1 + s1
        #判断是否旋转
        return self.is_substring(s2,s3)

4. 压缩字符串

挑战介绍

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

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

挑战内容

本次挑战中，你需要在 compress_str.py 文件中补充函数 compress 的空缺部分。

• compress 函数接受一个参数，string 用于指定传入的字符串;
• compress 函数输出一个字符串。

你需要补充 compress 函数，使 compress 函数可以对传入的 string 字符串进行压缩。要求如下：

• 判断传入的字符串是否需要进行压缩，如果不需要压缩，返回原字符串；
• 如果需要压缩，返回压缩后的字符串；
• 如果传入的字符串是 None 或者空字符串，返回 None 或者空字符串。

挑战要求

• 代码必须写入 compress_str.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 compress_str.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决的关键问题是压缩，并且尤其要注意的是，压缩的字符可能重复，简而言之就是字符串起始位置和后续位置可能出现相同字符，所以不能简单的只采用set进行去重后，统计不同字符的个数来解决这个问题。我们考虑使用贪心算法，依次读取字符串中的字符并进行字符个数统计和组合。

解决方案

#coding:utf-8
class CompressString(object):

    def compress(self, string):

        ### 补充代码 ###
        #判断字符串是否为None
        if (string is None) or (len(string) == 0):
            return string
        #判断字符串是否需要压缩
        if len(set(string)) > len(string):
            return string
        #创建最终我们需要的压缩后的字符串
        end_str = ''
        #创建我们已经遇到过的字符
        end_list = [string[0]]
        count = 0
        for i in range(len(string)):
            #如果与前一个元素相同
            if string[i] == end_list[-1]:
                count += 1
            else:
                if count != 1:
                    end_str += end_list[-1] + str(count)
                else:
                    end_str += end_list[-1]
                #与前一个元素不同，添加元素进入遇到过字符的列表中
                end_list.append(string[i])
                count = 1
        if count != 1:
            end_str += end_list[-1] + str(count)
        else:
            end_str += end_list[-1]
        if len(end_str) < len(string):
            return end_str
        else:
            return string

5. 反转字符串中的字符

挑战介绍

实现一个算法来实现反转字符数组的功能。反转的要求如下：

• 将字符数组的字符进行反转，例如 ['b', ' ', 'a', 'r'] 变成 ['r', 'a', ' ', 'b']。
• 将字符数组替换为反转后的数组。

挑战内容

本次挑战中，你需要在 reverse_chars.py 文件中补充函数 reverse 的空缺部分。

• reverse 函数接受一个参数，chars 用于指定传入的字符数组;
• reverse 函数输出一个字符数组。

你需要补充 reverse 函数，使 reverse 函数可以对传入的 chars 字符数组进行反转。要求如下：

• 对于传入的字符数组，将字符数组的字符进行反转和替换，并返回替换后的字符数组;
• 如果传入的字符数组是 None 或者空字符数组，返回 None 或者空字符数组。

挑战要求

• 代码必须写入 reverse_chars.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 reverse_chars.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决的关键问题是反转问题，只需要使用Python中最简单的列表反转函数即可。

解决方案

class ReverseString(object):

    def reverse(self, chars):

        ### 补充代码 ###
        #如果传入的字符数组为None或为空字符串
        if (chars is None) or (chars == ''):
            return chars
        #如果传入的字符串能够进行替换反转
        chars.reverse()
        return chars

6. 找到给定字符串中的不同字符

挑战介绍

在不考虑字符排列的条件下，对于相差只有一个字符的两个字符串，实现一个算法来识别相差的那个字符。要求如下：

• 当传入的字符串为 'aad' 和 'ad' 时，结果为 'a'。
• 当传入的字符串为 'aaabccdd' 和 'abdcacade' 时，结果为 'e'。

挑战内容

本次挑战中，你需要在 diff.py 文件中补充函数 find_diff 的空缺部分。

• find_diff 函数接受两个参数，str1，str2 用于指定传入的相差只有一个字符的两个字符串;
• find_diff 函数输出只有一个字符的字符串。

你需要补充 find_diff 函数，使 find_diff 函数可以识别传入的 str1，str2 之间相差的那个字符。要求如下：

• 对于传入的两个字符串，返回它们之间相差的那个字符;
• 如果传入的字符串有 None ，需要使用 raise 语句显示 TypeError。

挑战要求

• 代码必须写入 diff.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 diff.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

本题需要解决的关键问题是两个字符串之间相差一个字符，相差一个字符的问题，可以简化为观察两种情况。

• 两个字符串字符的种类相同，但字符的个数不同。
• 两个字符串字符的种类不相同，返回不相同的字符。（此处只需要事先排序好，最后哪个列表的长度长输出对应的最后一个元素即可）

解决方案

class Solution(object):

    def find_diff(self, str1, str2):

        ### 补充代码 ###
        #判断两个传入字符是否为空
        if str1 is None or str2 is None:
            raise TypeError
        #创建对应的字符字典（对应value值为元素的个数）
        str1_count_list = {}
        str2_count_list = {}
        #将字符串中的字符进行去重后排序，使得最终得出的两个字典中的item顺序相同
        str1_list = list(set(str1))
        str1_list.sort()
        str2_list = list(set(str2))
        str2_list.sort()
        #用字符：字符个数的形式填充字符字典
        for i in str1_list:
            str1_count_list[i] = str1.count(i)
        for i in str2_list:
            str2_count_list[i] = str2.count(i)
        #首先对比两者item去重后的长度是否相同，如果相同，则对比不同字符的个数即可。
        if len(str1_list) == len(str2_list):
            for i in str1_list:
                if str1_count_list[i] != str2_count_list[i]:
                    return i
        #如果长度不同，则需要返回不相同的唯一那个元素
        if len(str1_list) > len(str2_list):
            return str1_list[-1]
        if len(str1_list) < len(str2_list):
            return str2_list[-1]

7. 查找两个总和为特定值的索引

挑战介绍

给定一个数组，找到两个总和为特定值的索引。

• 例如给定数组 [1, 2, 3, -2, 5, 7]，给定总和 7，则返回索引 [1, 4]。

挑战内容

本次挑战中，你需要在 sum.py 文件中补充函数 two_sum 的空缺部分。

• two_sum 函数接受两个参数，nums 用于指定传入的数组，val 用于指定和的值;
• two_sum 函数输出含两个索引的数组，或者 TypeError、 ValueError。

你需要补充 two_sum 函数，使 two_sum 函数可以找到数组 nums 中两个总和为 val 的值的索引。要求如下：

• 对于传入的数组 nums，返回总和为 val 的两个值的索引;
• 如果数组中没有和为目标值的元素，则返回 None。
• 如果传入的数组 nums 或者目标值 val 为 None，需要使用 raise 语句显示 TypeError。
• 如果传入的数组为空数组，需要使用 raise 语句显示 ValueError。

挑战要求

• 代码必须写入 sum.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 sum.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

双重循环暴搜解决问题

解决方案

class Solution(object):

    def two_sum(self, nums, val):

        ### 补充代码 ###
        if nums is None or val is None:
            raise TypeError
        if nums == []:
            raise ValueError
        #如果传入的数组不含有问题
        for i in range(len(nums)):
            for j in range(i,len(nums)):
                if nums[i] + nums[j] == val:
                    return [i,j]
        return None

8. Fizz Buzz 经典问题

挑战介绍

给定一个整数 num，从 1 到 num 按照下面的规则返回每个数：

• 如果这个数被 3 整除，返回 'Fizz'。
• 如果这个数被 5 整除，返回 'Buzz'。
• 如果这个数能同时被 3 和 5 整除，返回 'FizzBuzz'。
• 如果这个数既不能被 3 也不能被 5 整除，返回这个数字的字符串格式。

挑战内容

本次挑战中，你需要在 fizzbuzz.py 文件中补充函数 fizz_buzz 的空缺部分。

• fizz_buzz 函数接受一个参数，num 用于指定传入的整数;
• fizz_buzz 函数输出一个数组。

你需要补充 fizz_buzz 函数，使 fizz_buzz 函数可以识别从 1 到 num 中能被 3 或 5 整除的数。要求如下：

• 对于传入的整数 num，返回长度为 num 的数组，数组的每个值由 Fizz Buzz 的规则构成;
• 如果传入的数为 None，需要使用 raise 语句显示 TypeError。
• 如果传入的整数小于 1，需要使用 raise 语句显示 ValueError。

挑战要求

• 代码必须写入 fizzbuzz.py 文件中，且不能修改示例代码中出现的类名和函数名。
• 请自行在环境主目录下新建 fizzbuzz.py 文件，并复制示例代码到文件中完成补充。补充完整后点击「提交检测」，系统将会给出判定结果。

---

思路

简单的条件判断问题

解决方案

class Solution(object):

    def fizz_buzz(self, num):
        if num is None:
            raise TypeError('num cannot be None')
        if num < 1:
            raise ValueError('num cannot be less than one')
        results = []
        for i in range(1, num + 1):
            if i % 3 == 0 and i % 5 == 0:
                results.append('FizzBuzz')
            elif i % 3 == 0:
                results.append('Fizz')
            elif i % 5 == 0:
                results.append('Buzz')
            else:
                results.append(str(i))
        return results