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

介绍

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

课程内容和方向

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

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

试题1：农场采摘水果问题

问题描述：

小U正在探访一座农场，农场的果树排成一列，用整数数组 fruits 表示，每个元素 fruits[i] 是第 i 棵树上的水果种类。

小U有两个篮子，每个篮子只能装一种类型的水果，而且每个篮子可以装无限量的水果。小U从任意一棵树开始，必须从每棵树上恰好采摘一个水果，并且只能装入符合篮子中水果类型的果实。如果某棵树上的水果类型不符合篮子中的水果类型，则必须停止采摘。

请你帮助小U计算他最多可以采摘多少个水果。

例如：当 fruits = [1,2,3,2,2] 时，小U最多可以采摘的树是从第2棵开始，采摘到最后的 4 棵树，结果为 [2,3,2,2]。

def solution(fruits: list) -> int:
    # 初始化变量
    max_length = 0
    start = 0
    fruit_count = {}
    
    # 遍历数组
    for end in range(len(fruits)):
        # 将当前水果加入窗口
        fruit = fruits[end]
        if fruit in fruit_count:
            fruit_count[fruit] += 1
        else:
            fruit_count[fruit] = 1
        
        # 如果窗口中的水果类型超过两种，收缩窗口
        while len(fruit_count) > 2:
            # 从窗口中移除起始位置的水果
            start_fruit = fruits[start]
            fruit_count[start_fruit] -= 1
            if fruit_count[start_fruit] == 0:
                del fruit_count[start_fruit]
            start += 1
        
        # 更新最大长度
        max_length = max(max_length, end - start + 1)
    
    return max_length

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

试题2：出现次数最多字符的质数判定

问题描述：

给定一个由小写字母组成的字符串s，要求统计每个字符出现的次数，并判断出现次数最多的字符的出现次数是否为质数。如果是质数，输出 "YES"，否则输出 "NO"。

from collections import Counter

def is_prime(n: int) -> bool:
    # 判断一个数是否为质数的函数
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def solution(s: str) -> str:
    # 统计每个字符的出现次数
    char_count = Counter(s)
    
    # 找到出现次数最多的字符的出现次数
    max_count = max(char_count.values())
    
    # 判断这个次数是否为质数
    if is_prime(max_count):
        return "YES"
    else:
        return "NO"

if __name__ == '__main__':
    print(solution("abccckjskw") == "YES")
    print(solution("qwqwtttqqttttt") == "NO")
    print(solution("aabbbccddd") == "YES")
    print(solution("xyzzzz") == "NO")
    print(solution("mmnnooo") == "YES")

试题3：分糖果给小朋友

问题描述：

def solution(candies: int, n: int) -> list:
    # 初始化每个小朋友的糖果数数组
    result = [0] * n
    
    # 初始化当前分发的糖果数和轮次
    current_candy = 1
    while candies > 0:
        for i in range(n):
            # 如果剩余糖果数大于当前小朋友应得的糖果数
            if candies >= current_candy:
                # 更新当前小朋友的糖果数
                result[i] += current_candy
                # 更新剩余糖果数
                candies -= current_candy
            else:
                # 如果剩余糖果数不足以满足当前轮次分发的要求
                result[i] += candies
                candies = 0
                break
            # 增加当前分发的糖果数
            current_candy += 1
    
    return result

if __name__ == '__main__':
    print(solution(candies=7, n=4) == [1, 2, 3, 1])
    print(solution(candies=10, n=3) == [5, 2, 3])
    print(solution(candies=20, n=5) == [6, 2, 3, 4, 5])

试题4：判断子数组能否被5整除的问题

问题描述：

小R有一个二进制数组 nums，其中的下标从 0 开始。我们定义 xi 为从最高有效位到最低有效位的子数组 nums[0...i] 所表示的二进制数。例如，如果 nums = [1, 0, 1]，那么 x0 = 1，x1 = 2，x2 = 5。

小R想知道，对于每个 xi，它能否被 5 整除。你需要返回一个布尔值列表 answer，当 xi 能够被 5 整除时，answer[i] 为 true，否则为 false。

def solution(nums: list) -> list:
    # 初始化一个列表来存储结果
    answer = []
    
    # 初始化一个变量来存储当前的二进制数
    current_value = 0
    
    # 遍历数组中的每一个元素
    for i, num in enumerate(nums):
        # 更新当前的二进制数
        # 提示：每次迭代时，current_value 需要左移一位，并加上当前的 num
        current_value = (current_value << 1) + num
        
        # 检查 current_value 是否能被 5 整除
        # 提示：使用取模运算符 % 来判断是否能被 5 整除
        if current_value % 5 == 0:
            answer.append(True)
        else:
            answer.append(False)
    
    return answer

if __name__ == '__main__':
    print(solution(nums=[0, 1, 1]) == [True, False, False])
    print(solution(nums=[1, 0, 1, 1, 0]) == [False, False, True, False, False])
    print(solution(nums=[1, 1, 1]) == [False, False, False])

试题5：区间内选择整数求和

问题描述：

小S拥有三个正整数：L、R 和 S。他想知道能否从 L 到 R（包含 L 和 R）之间选择一些整数，使它们的总和正好等于 S。

请注意，从 L 到 R 的每个整数最多只能选择一次。如果可以找到满足条件的整数集合，请返回 1，否则返回 0。

例如：当 L = 5，R = 8，S = 12 时，可以选择整数 5 和 7，因为它们的和是 12，所以答案为 1。

def solution(L: int, R: int, S: int) -> int:
    # 生成从 L 到 R 的所有整数
    nums = list(range(L, R + 1))
    
    # 定义一个辅助函数来进行回溯
    def backtrack(start, target):
        # 如果目标值为0，说明找到了一个子集，返回 True
        if target == 0:
            return True
        # 如果目标值小于0，或者已经遍历完所有数，返回 False
        if target < 0 or start == len(nums):
            return False
        # 尝试选择当前数
        if backtrack(start + 1, target - nums[start]):
            return True
        # 尝试不选择当前数
        return backtrack(start + 1, target)
    
    # 调用回溯函数，从第一个数开始，目标值为 S
    return 1 if backtrack(0, S) else 0

if __name__ == '__main__':
    print(solution(L = 5, R = 8, S = 12) == 1)
    print(solution(L = 3, R = 10, S = 17) == 1)
    print(solution(L = 1, R = 5, S = 20) == 0)

试题6：单词出现频率统计

问题描述：

小U在学习英文时，需要统计英文句子中每个单词的出现次数，并按照字母顺序将统计结果进行排序。请你帮助小U编写一个程序，统计输入的英文句子中每个单词的出现次数，并将结果按字母顺序排序后输出。

from collections import Counter

def solution(s: str) -> list:
    # 1. 分割句子为单词列表
    words = s.split()
    
    # 2. 统计每个单词的出现次数
    word_count = Counter(words)
    
    # 3. 按照字母顺序对单词进行排序
    sorted_words = sorted(word_count.keys())
    
    # 4. 格式化输出
    result = [f"{word}:{word_count[word]}" for word in sorted_words]
    
    return result

if __name__ == '__main__':
    print(solution("New to Python or choosing between Python 2 and Python 3 Read Python 2 or Python 3") == ['2:2', '3:2', 'New:1', 'Python:5', 'Read:1', 'and:1', 'between:1', 'choosing:1', 'or:2', 'to:1'])
    print(solution("hello world hello python") == ['hello:2', 'python:1', 'world:1'])
    print(solution("the quick brown fox jumps over the lazy dog") == ['brown:1', 'dog:1', 'fox:1', 'jumps:1', 'lazy:1', 'over:1', 'quick:1', 'the:2'])