青训营-豆包MarsCode技术训练营试题解析三十四

引言

随着AI领域的发展，底层算法确实起到了决定性的作用。为了跟上这个快速发展的领域，我们需要不断学习和提升自己的技能。刷题是一种很好的方式，可以帮助我们巩固基础知识，提高解决问题的能力。

介绍

‌豆包青训营‌是由字节跳动和稀土掘金社区共同发起的技术培训和人才选拔项目。该项目的目标是培养具有职业竞争力的优秀开发工程师，并提供全程免费的课程，不收取任何费用‌。

课程内容和方向

豆包青训营的课程涵盖前端、后端和AI方向。在这个飞速发展的AI时代，学员将与豆包MarsCode团队一起深入探索技术领域，学习和运用AI，提高编程效率‌。此外，课程还包括大数据方向，适合对大数据感兴趣的学员学习‌，

本文提供训练营试题解析供参考

试题1：计算特定条件下的四元组数量

问题描述：

def solution(n: int, a: list) -> int:
    MOD = 10**9 + 7
    count = 0
    
    # 遍历所有可能的四元组 (i, j, k, l)
    for i in range(n):
        for j in range(i + 1, n):
            for k in range(j + 1, n):
                for l in range(k + 1, n):
                    # 检查条件 a[i] + a[j] == a[k] ⊕ a[l]
                    if a[i] + a[j] == a[k] ^ a[l]:
                        count += 1
    
    # 返回结果并对 MOD 取模
    return count % MOD

if __name__ == '__main__':
    print(solution(5, [2, 3, 1, 5, 4]) == 1)
    print(solution(6, [1, 2, 3, 4, 5, 6]) == 1)
    print(solution(4, [4, 1, 3, 2]) == 0)

试题2：'icci’型字符串串子序列问题

问题描述：
小U定义了一种特殊的字符串类型，称为 “icci” 型字符串。要满足这个类型，字符串必须具备以下条件：

它的长度为 4。
第一个和第四个字符必须是元音字母（‘a’, ‘e’, ‘i’, ‘o’, ‘u’）。
第二个和第三个字符必须是辅音字母（除了元音以外的字母）。
该字符串是一个回文串。
例如，字符串 “awwa” 和 “uttu” 都是 “icci” 型字符串。现在给定一个字符串，小U想知道其中有多少个 “icci” 型的子序列。

def solution(s: str) -> int:
    vowels = {'a', 'e', 'i', 'o', 'u'}
    consonants = set('bcdfghjklmnpqrstvwxyz')
    
    count = 0
    
    # 遍历所有可能的子序列
    for i in range(len(s)):
        for j in range(i + 1, len(s)):
            for k in range(j + 1, len(s)):
                for l in range(k + 1, len(s)):
                    # 获取子序列
                    subseq = s[i] + s[j] + s[k] + s[l]
                    
                    # 检查子序列是否满足条件
                    if (subseq[0] in vowels and subseq[3] in vowels and
                        subseq[1] in consonants and subseq[2] in consonants and
                        subseq == subseq[::-1]):
                        count += 1
    
    return count

if __name__ == '__main__':
    print(solution("iiaabbii") == 4)
    print(solution("aekekeo") == 1)
    print(solution("abcdefg") == 0)

试题3：三数之和问题

问题描述：
小U有一个整数数组 arr，他希望找到其中三个元素 i, j, k 满足条件 i < j < k 且 arr[i] + arr[j] + arr[k] == target。由于可能存在大量的元组，结果需要对 10^9 + 7 取模。

例如：当 arr = [1,1,2,2,3,3,4,4,5,5] 且 t = 8 时，有多个元组满足条件，你需要返回这些元组的数量。

def solution(arr: list, t: int) -> int:
    MOD = 10**9 + 7
    arr.sort()  # 对数组进行排序
    count = 0
    
    # 使用三重循环遍历所有可能的三元组 (i, j, k)
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            for k in range(j + 1, len(arr)):
                # 检查是否满足条件
                if arr[i] + arr[j] + arr[k] == t:
                    # 计算这种组合的数量
                    count += 1
                    count %= MOD  # 取模
    
    return count

if __name__ == '__main__':
    print(solution([1, 1, 2, 2, 3, 3, 4, 4, 5, 5], 8) == 20)
    print(solution([2, 2, 2, 2], 6) == 4)
    print(solution([1, 2, 3, 4, 5], 9) == 2)
    print(solution([1, 1, 1, 1], 3) == 4)

试题4：不同子序列计数问题

问题描述：
小U有一个字符串 s，他想计算该字符串的所有不同非空子序列的个数。子序列是通过删除原字符串中的部分字符（也可以不删除），且保持剩余字符的相对顺序形成的新字符串。

你的任务是帮助小U计算 s 的不同非空子序列的总数，并返回对 10^9 + 7 取余的结果。

例如：当 s = “abc” 时，所有不同的非空子序列包括 “a”, “b”, “c”, “ab”, “ac”, “bc”, 和 “abc”，总数为 7。

def solution(s: str) -> int:
    MOD = 10**9 + 7
    # 初始化一个字典来记录每个字符最后一次出现的位置
    last_occurrence = {}
    # 初始化当前不同子序列的总数
    count = 0
    
    for i, char in enumerate(s):
        # 保存当前的count值，用于后续更新
        prev_count = count
        
        if char in last_occurrence:
            # 如果字符之前出现过，减去之前该字符出现时的子序列数
            count = (count * 2 - last_occurrence[char]) % MOD
        else:
            # 如果字符之前没有出现过，新的子序列数就是当前count加上1
            count = (count * 2 + 1) % MOD
        
        # 更新字符最后一次出现的位置
        last_occurrence[char] = prev_count
    
    # 返回最终结果，注意要取模
    return count

if __name__ == '__main__':
    print(solution("abc") == 7)
    print(solution("aaa") == 3)
    print(solution("abcd") == 15)
    print(solution("abac") == 13)

试题5：二进制尾零子数组问题

问题描述：

def solution(n: int, k: int, a: list) -> int:
    # 计算每个元素包含多少个因子2
    def count_factors_of_two(x):
        count = 0
        while x % 2 == 0:
            x //= 2
            count += 1
        return count
    
    # 计算前缀和数组，记录从数组开头到当前位置的所有元素中因子2的累积数量
    prefix_factors_of_two = [0] * (n + 1)
    for i in range(n):
        prefix_factors_of_two[i + 1] = prefix_factors_of_two[i] + count_factors_of_two(a[i])
    
    # 使用滑动窗口找到最短的子数组，使得其乘积包含至少k个因子2
    left = 0
    min_length = float('inf')
    
    for right in range(1, n + 1):
        while prefix_factors_of_two[right] - prefix_factors_of_two[left] >= k:
            min_length = min(min_length, right - left)
            left += 1
    
    return min_length if min_length != float('inf') else -1

if __name__ == '__main__':
    print(solution(n = 6, k = 3, a = [1, 2, 3, 4, 5, 6]) == 3)
    print(solution(n = 5, k = 2, a = [10, 2, 8, 5, 4]) == 1)
    print(solution(n = 4, k = 4, a = [1, 3, 5, 7]) == -1)