AI加码，青训营X豆包MarsCode 技术训练营，入营任务。
1.小U的早餐选择计算
def solution(staples: list, drinks: list, x: int) -> int:
count = 0
# 遍历主食列表
for s in staples:
if s <= x:
count += 1
# 遍历饮料列表
for d in drinks:
if d <= x:
count += 1
# 组合选择
for s in staples:
for d in drinks:
if s + d <= x:
count += 1
return count
if __name__ == '__main__':
print(solution(staples=[5, 20, 5], drinks=[5, 5, 2], x=5) == 5)
print(solution(staples=[3, 10, 7], drinks=[2, 5], x=7) == 5)
print(solution(staples=[10, 15], drinks=[5, 6], x=20) == 7)
2.不同整数的计数问题
def solution(word):
# 替换非数字字符为空格
replaced_word = ''.join(' ' if not char.isdigit() else char for char in word)
# 分割字符串得到数字列表
numbers = replaced_word.split()
# 去除前导零（保留单个'0'）并存储到集合中
distinct_integers = {number.lstrip('0') or '0' for number in numbers}
# 由于集合自动去重，直接返回集合的大小即可
return len(distinct_integers)
# 测试样例
print(solution("a123bc34d8ef34")) # 输出: 3
print(solution("t1234c23456")) # 输出: 2
print(solution("a1b01c001d4")) # 输出: 2（正确地将"01"和"001"视为"1"，
3.小x走字符串
def solution(n: int, k: int, s: str) -> int:
# 初始体力值
current_energy = k
# 遍历字符串
for i in range(n - 1):
# 计算当前字符和下一个字符的体力变化
energy_change = ord(s[i + 1]) - ord(s[i])
# 更新体力值
current_energy -= energy_change
# 如果体力值小于0，返回-1
if current_energy < 0:
return -1
# 返回剩余的体力值
return current_energy
if __name__ == '__main__':
print(solution(5, 2, "abcca") == 2)
print(solution(6, 5, "abcdef") == 0)
print(solution(4, 1, "acdb") == -1)
4.数组操作和最大分数
def solution(nums, k):
# 初始化哈希表
count = {}
# 遍历数组
for num in nums:
# 计算替换范围
for new_num in range(num - k, num + k + 1):
# 更新哈希表
if new_num in count:
count[new_num] += 1
else:
count[new_num] = 1
# 统计最大值
max_score = 0
for key in count:
if count[key] > max_score:
max_score = count[key]
return max_score
if __name__ == "__main__":
print(solution([4, 6, 1, 2], 2) == 3)
print(solution([1, 3, 5, 7], 1) == 2)
print(solution([1, 3, 5, 7], 3) == 4)
5.数组极差最小化问题
def solution(n: int, a: list) -> int:
min_diff = float('inf') # 初始化最小极差为一个较大的值
for i in range(n - 1):
# 合并相邻的两个元素
new_array = a[:i] + [a[i] + a[i + 1]] + a[i + 2:]
# 计算新数组的极差
current_diff = max(new_array) - min(new_array)
# 更新最小极差
if current_diff < min_diff:
min_diff = current_diff
return min_diff
if __name__ == '__main__':
print(solution(3, [1, 4, 5]) == 0)
print(solution(5, [3, 6, 2, 8, 7]) == 5)
print(solution(4, [10, 20, 30, 40]) == 10)
简单
1数字分组求偶数和
from itertools import product
def solution(numbers):
def get_digits(group):
# 将每个数字转换为单个数字的列表
return [int(digit) for digit in str(group)]
# 从每个数字组中选择一个数字的所有可能组合
all_combinations = product(*[get_digits(group) for group in numbers])
# 计算和为偶数的组合数量
even_sum_combinations = sum(1 for combination in all_combinations if sum(combination) % 2 == 0)
return even_sum_combinations
# 测试样例
print(solution([123, 456, 789])) # 输出：14
print(solution([123456789])) # 输出：4
print(solution([14329, 7568])) # 输出：10
2，DNA序列编辑距离
def solution(dna1, dna2):
len1, len2 = len(dna1), len(dna2)
# 初始化动态规划矩阵
dp = [[0] * (len2 + 1) for _ in range(len1 + 1)]
# 初始化第一行和第一列
for i in range(len1 + 1):
dp[i][0] = i
for j in range(len2 + 1):
dp[0][j] = j
# 填充动态规划矩阵
for i in range(1, len1 + 1):
for j in range(1, len2 + 1):
if dna1[i - 1] == dna2[j - 1]:
dp[i][j] = dp[i - 1][j - 1] # 相同字符，无需操作
else:
dp[i][j] = 1 + min(
dp[i - 1][j], # 删除操作
dp[i][j - 1], # 插入操作
dp[i - 1][j - 1] # 替换操作
)
return dp[len1][len2]
# 测试样例
print(solution("AGT", "AGCT")) # 输出：1
print(solution("AACCGGTT", "AACCTTGG")) # 输出：4
print(solution("ACGT", "TGC")) # 输出：3
print(solution("A", "T")) # 输出：1
print(solution("GGGG", "TTTT")) # 输出：4
3，环状DNA序列的最小表示法
def solution(dna_sequence):
# 将DNA序列转换为列表，以便于进行循环移位
dna_list = list(dna_sequence)
# 初始化最小序列为原始序列
min_sequence = dna_sequence
# 遍历所有可能的循环移位
for i in range(len(dna_sequence)):
# 将序列向右移动i个位置
rotated_sequence = dna_list[i:] + dna_list[:i]
# 将旋转后的序列转换回字符串
rotated_str = ''.join(rotated_sequence)
# 如果旋转后的序列小于当前的最小序列，则更新最小序列
if rotated_str < min_sequence:
min_sequence = rotated_str
# 返回字典序最小的序列
return min_sequence
# 测试样例
print(solution("ATCA")) # 输出：'AATC'
print(solution("CGAGTC")) # 输出：'AGTCCG'
print(solution("TTGAC")) # 输出：'ACTTG'
4打点计时器的区间合并
def solution(inputArray):
# 根据每个范围的起始值对输入数组进行排序
inputArray.sort(key=lambda x: x[0])
# 初始化合并后的范围列表
merged_ranges = []
# 遍历排序后的数组并合并重叠的范围
for current_range in inputArray:
if not merged_ranges or current_range[0] > merged_ranges[-1][1]:
# 如果合并后的范围列表为空，或者当前范围的起始值大于最后一个范围的结束值，则直接添加当前范围
merged_ranges.append(current_range)
else:
# 否则，合并当前范围与最后一个范围
merged_ranges[-1][1] = max(merged_ranges[-1][1], current_range[1])
# 计算合并后范围内的唯一数字总数
total_unique_numbers = sum(end - start + 1 for start, end in merged_ranges)
return total_unique_numbers
# 测试样例
print(solution([[1, 4], [7, 10], [3, 5]])) # 输出：9
print(solution([[1, 2], [6, 10], [11, 15]])) # 输出：12
print(solution([[1, 3], [2, 6], [8, 10]])) # 输出：9
5叠盘子排序
def solution(plates, n):
# 首先对盘子序号进行排序
plates.sort()
# 初始化结果列表
result = []
start = 0
# 遍历排序后的盘子序号数组
for i in range(1, n):
# 如果当前盘子序号与前一个盘子序号不连续
if plates[i] != plates[i - 1] + 1:
# 检查当前序列的长度是否至少为3
if i - start >= 3:
result.append(f"{plates[start]}-{plates[i - 1]}")
else:
for j in range(start, i):
result.append(str(plates[j]))
# 开始新的序列
start = i
# 处理最后一个序列
if n - start >= 3:
result.append(f"{plates[start]}-{plates[-1]}")
else:
for j in range(start, n):
result.append(str(plates[j]))
# 返回结果字符串
return ",".join(result)
# 测试样例
print(solution([-3, -2, -1, 2, 10, 15, 16, 18, 19, 20], 10)) # 输出："-3--1,2,10,15,16,18-20"
print(solution([-6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20], 20)) # 输出："-6,-3-1,3-5,7-11,14,15,17-20"
print(solution([1, 2, 7, 8, 9, 10, 11, 19], 8)) # 输出："1,2,7-11,19"
6找出整型数组中占比超过一半的数
def solution(array):
# 初始化候选人和得票数
candidate = None
count = 0
# 遍历数组
for num in array:
if count == 0:
candidate = num
count = 1
elif candidate == num:
count += 1
else:
count -= 1
# 返回出现次数超过一半的数字
return candidate
# 测试样例
print(solution([1, 3, 8, 2, 3, 1, 3, 3, 3])) # 输出：3
print(solution([5, 5, 5, 1, 2, 5, 5])) # 输出：5
print(solution([9, 9, 9, 9, 8, 9, 8, 8])) # 输出：9
7补给站最优花费
def solution(m, n, p):
# 初始化dp数组
dp = [float('inf')] * (m + 1)
dp[0] = 0 # 第0天的花费为0
# 遍历补给站
for day, cost in p:
# 更新到达该补给站当天及之后天数的最小花费
for i in range(day, m + 1):
dp[i] = min(dp[i], dp[day] + (i - day) * cost)
# 返回到达目的地的最小花费
return dp[m]
# 测试样例
print(solution(5, 4, [[0, 2], [1, 3], [2, 1], [3, 2]])) # 输出：7
print(solution(6, 5, [[0, 1], [1, 5], [2, 2], [3, 4], [5, 1]])) # 输出：6
print(solution(4, 3, [[0, 3], [2, 2], [3, 1]])) # 输出：9
8 完美整数
def solution(x, y):
def is_perfect(n):
# 将整数转换为字符串
str_n = str(n)
# 检查所有字符是否相同
return all(c == str_n[0] for c in str_n)
# 初始化计数器
count = 0
# 遍历区间 [x, y]
for i in range(x, y + 1):
# 检查是否是完美整数
if is_perfect(i):
count += 1
# 返回完美整数的数量
return count
# 测试样例
print(solution(1, 10)) # 输出：9
print(solution(2, 22)) # 输出：10
9游戏队友搜索
def solution(id, num, array):
# 构建比赛到玩家的映射
game_to_players = {}
for player_id, game_id in array:
if game_id not in game_to_players:
game_to_players[game_id] = set()
game_to_players[game_id].add(player_id)
# 构建玩家到比赛的映射
player_to_games = {}
for player_id, game_id in array:
if player_id not in player_to_games:
player_to_games[player_id] = set()
player_to_games[player_id].add(game_id)
# 查找共同比赛的玩家
teammates = set()
for game_id, players in game_to_players.items():
if id in players:
# 计算共同比赛的次数
for player_id in players:
if player_id != id:
common_games = len(player_to_games[player_id] & player_to_games[id])
if common_games >= 2:
teammates.add(player_id)
# 返回符合条件的队友列表
return sorted(list(teammates))
# 测试样例
print(solution(1, 10, [[1,1], [1,2], [1,3], [2,1], [2,4], [3,2], [4,1], [4,2], [5,2], [5,3]])) # 输出：[4, 5]
print(solution(2, 6, [[2,1], [2,3], [1,1], [1,2], [3,1], [4,3]])) # 输出：[]
print(solution(3, 8, [[3,1], [3,2], [3,3], [4,1], [5,2], [6,3], [7,1], [7,2]])) # 输出：[7]
困难题
1二进制之和
def solution(binary1, binary2):
# 将两个二进制字符串转换为整数
num1 = int(binary1, 2)
num2 = int(binary2, 2)
# 计算两个整数的和
total = num1 + num2
# 返回十进制的求和结果
return str(total)
# 测试样例
print(solution("101", "110")) # 输出：'11'
print(solution("111111", "10100")) # 输出：'83'
print(solution("111010101001001011", "100010101001")) # 输出：'242420'
print(solution("111010101001011", "10010101001")) # 输出：'31220'
print(solution("11", "1")) # 输出：'4'
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
