代码收藏家 稀土掘金——AI刷题3（python版）
打点计数器的区间合并
问题描述
小明正在设计一台打点计数器，该计数器可以接受多个递增的数字范围，并对这些范围内的每个唯一数字打点。如果多个范围之间有重叠，计数器将合并这些范围并只对每个唯一数字打一次点。小明需要你帮助他计算，在给定的多组数字范围内，计数器会打多少个点。
例如，给定三个数字范围 [1, 4], [7, 10], 和 [3, 5]，计数器首先将这些范围合并，变成 [1, 5] 和 [7, 10]，然后计算这两个范围内共有多少个唯一数字，即从 1 到 5 有 5 个数字，从 7 到 10 有 4 个数字，共打 9 个点。
测试样例
样例1：
输入：
inputArray = [[1, 4], [7, 10], [3, 5]]
输出：9
样例2：
输入：
inputArray = [[1, 2], [6, 10], [11, 15]]
输出：12
样例3：
输入：
inputArray = [[1, 3], [2, 6], [8, 10]]
输出：9
def solution(inputArray):
# Step 1: Sort the input ranges based on the start of each range
inputArray.sort(key=lambda x: x[0])
merged_ranges = []
for current_range in inputArray:
if not merged_ranges:
merged_ranges.append(current_range)
else:
last_range = merged_ranges[-1]
# Step 2: Check for overlap
if current_range[0] <= last_range[1]: # There is an overlap
# Merge the ranges
last_range[1] = max(last_range[1], current_range[1])
else:
merged_ranges.append(current_range)
# Step 3: Calculate the total number of unique points
total_points = 0
for start, end in merged_ranges:
total_points += (end - start + 1)
return total_points
if __name__ == "__main__":
# Test cases
testArray1 = [[1, 4], [7, 10], [3, 5]]
testArray2 = [[1, 2], [6, 10], [11, 15]]
testArray3 = [[1, 3], [2, 6], [8, 10]]
print(solution(testArray1) == 9)
print(solution(testArray2) == 12)
print(solution(testArray3) == 9)
分组飞行棋棋子
问题描述
小M和小F在玩飞行棋。游戏结束后，他们需要将桌上的飞行棋棋子分组整理好。现在有 N 个棋子，每个棋子上有一个数字序号。小M的目标是将这些棋子分成 M 组，每组恰好5个，并且组内棋子的序号相同。小M希望知道是否可以按照这种方式对棋子进行分组。
例如，假设棋子序号为 [1, 2, 3, 4, 5]，虽然只有5个棋子，但由于序号不同，因此不能形成有效的分组。如果序号是 [1, 1, 1, 1, 1, 2, 2, 2, 2, 2]，则可以形成两个有效分组，因此输出为 True。
测试样例
样例1：
输入：
nums = [1, 2, 3, 4, 5]
输出："False"
样例2：
输入：
nums = [1, 1, 1, 1, 2, 1, 2, 2, 2, 2]
输出："True"
样例3：
输入：
nums = [5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
输出："True"
样例4：
输入：
nums = [7, 7, 7, 8, 8, 8, 8, 8, 7, 7]
输出："True"
样例5：
输入：
nums = [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
输出："False"
from collections import Counter
def solution(nums: list[int]) -> str:
# 统计每种棋子的数量
count = Counter(nums)
# 检查每种棋子的数量
for key in count:
if count[key] % 5 != 0:
return "False"
return "True"
if __name__ == "__main__":
print(solution([1, 2, 3, 4, 5]) == "False")
print(solution([1, 1, 1, 1, 2, 1, 2, 2, 2, 2]) == "True")
print(solution([5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) == "True")
print(solution([7, 7, 7, 8, 8, 8, 8, 8, 7, 7]) == "True")
print(solution([9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9]) == "False")
时尚圈的衣着稳定性问题
问题描述
小U在时尚圈组织了一场“校服日”活动，有 n 名学生围成一圈参加活动。每位学生都穿着白色或黑色的校服，白色用 0 表示，黑色用 1 表示。每一天，如果某个学生发现自己和相邻的两位学生穿着相同颜色的校服，那么他会在第二天更换成另一种颜色的校服；否则，他会保持不变。
你的任务是帮助小U判断，在第几天学生们的穿着会达到稳定状态——即某一天后，所有学生的穿着不再发生任何变化。同时，你还需要计算在稳定后，有多少学生的校服颜色与其相邻的同学不同，这些学生被称为“时尚达人”。
最终你需要返回一个包含两个元素的数组：
-1。-1。测试样例
样例1：
输入：
n = 4 ,data = "0000"
输出：[-1, -1]
样例2：
输入：
n = 4 ,data = "1110"
输出：[2, 4]
样例3：
输入：
n = 6 ,data = "010101"
输出：[1, 6]
def solution(n, data):
current_state = list(data)
days = 0
max_days = 100 # 限制最大天数，防止无限循环
while days < max_days:
new_state = current_state.copy()
change_occurred = False
for i in range(n):
left = current_state[(i - 1) % n] # 左边的学生
right = current_state[(i + 1) % n] # 右边的学生
if current_state[i] == left and current_state[i] == right:
new_state[i] = '1' if current_state[i] == '0' else '0'
change_occurred = True
days += 1
current_state = new_state
if not change_occurred:
break # 没有变化，达到稳定状态
if days == max_days:
return [-1, -1] # 永远无法稳定
# 计算时尚达人
fashionistas = 0
for i in range(n):
if current_state[i] != current_state[(i - 1) % n] and current_state[i] != current_state[(i + 1) % n]:
fashionistas += 1
return [days, fashionistas]
# 测试用例
if __name__ == "__main__":
print(solution(4, "0000") == [-1, -1])
print(solution(4, "1110") == [2, 4])
print(solution(6, "010101") == [1, 6])
统计班级中的说谎者
问题描述
在小C的班级里，有 N 个学生，每个学生的成绩是 A_i。小C发现了一件有趣的事：当且仅当某个学生的成绩小于或等于自己的有更多人时，这个学生会说谎。换句话说，如果分数小于等于他的学生数量大于比他分数高的学生数量，则他会说谎。
现在，小C想知道班里有多少个学生会说谎。
测试样例
样例1：
输入：
A = [100, 100, 100]
输出：3
样例2：
输入：
A = [2, 1, 3]
输出：2
样例3：
输入：
A = [30, 1, 30, 30]
输出：3
样例4：
输入：
A = [19, 27, 73, 55, 88]
输出：3
样例5：
输入：
A = [19, 27, 73, 55, 88, 88, 2, 17, 22]
输出：5
def solution(A):
# 获取学生总数
n = len(A)
# 初始化说谎者计数
liars = 0
# 遍历每个学生的成绩
for score in A:
# 计算小于或等于该分数的学生数量
less_equal_count = sum(1 for x in A if x <= score)
# 计算比该分数高的学生数量
greater_count = n - less_equal_count
# 说谎的条件
if less_equal_count > greater_count:
liars += 1
return liars
if __name__ == "__main__":
# 测试用例
print(solution([100, 100, 100]) == 3) # True
print(solution([2, 1, 3]) == 2) # True
print(solution([30, 1, 30, 30]) == 3) # True
print(solution([19, 27, 73, 55, 88]) == 3) # True
print(solution([19, 27, 73, 55, 88, 88, 2, 17, 22]) == 5) # True
五子棋获胜策略
问题描述
假设存在一个五子棋棋盘，大小未知。棋盘上已经摆放了一些白色棋子，现在你的手中还有一个白色棋子。你的任务是找出在棋盘的哪些位置摆放这个棋子，能够使棋盘上出现五颗棋子连成一线（不限于横向、纵向或斜向）。
备注：棋盘上当前不存在连成一条线的五个棋子，但至少存在一个点可以通过摆放使得形成五子连线。
测试样例
样例1：
输入：
n = 6, array = [[0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0]]
输出：[[1, 1], [6, 6]]
样例2：
输入：
n = 5, array = [[1, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 0]]
输出：[[5, 5]]
样例3：
输入：
n = 5, array = [[1, 0, 1, 0, 0], [1, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 0]]
输出：[]
def check_win(board, x, y):
directions = [
(0, 1), # 横向
(1, 0), # 纵向
(1, 1), # 主对角线
(1, -1) # 反对角线
]
for dx, dy in directions:
count = 1 # count will include the placed stone
# Check in the positive direction
nx, ny = x + dx, y + dy
while 0 <= nx < len(board) and 0 <= ny < len(board) and board[nx][ny] == 1:
count += 1
nx += dx
ny += dy
# Check in the negative direction
nx, ny = x - dx, y - dy
while 0 <= nx < len(board) and 0 <= ny < len(board) and board[nx][ny] == 1:
count += 1
nx -= dx
ny -= dy
if count >= 5: # If 5 or more in a row
return True
return False
def solution(n, array):
result = []
# Check all positions
for i in range(n):
for j in range(n):
if array[i][j] == 0: # Only check empty spots
# Temporarily place a piece here
array[i][j] = 1
if check_win(array, i, j): # Check if this forms a winning line
result.append([i + 1, j + 1]) # Store 1-based index
array[i][j] = 0 # Restore the position
return result
if __name__ == "__main__":
array1 = [
[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0],
]
print(solution(6, array1) == [[1, 1], [6, 6]]) # 应输出 [[1, 1], [6, 6]]
array2 = [
[1, 0, 1, 0, 0],
[0, 1, 0, 0, 0],
[1, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 0],
]
print(solution(5, array2) == [[5, 5]]) # 应输出 [[5, 5]]
array3 = [
[1, 0, 1, 0, 0],
[1, 1, 0, 0, 0],
[1, 0, 0, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 0],
]
print(solution(5, array3) == [])
版本号比较
问题描述
在某个项目中，每个版本都用版本号标记，由一个或多个修订号组成，修订号之间由点号.分隔。每个修订号可能有多位数字，并且可能会包含前导零。你需要根据两个版本号 version1 和 version2，判断哪个版本更新，或者它们是否相同。
例如，2.5.33 和 0.1 都是有效的版本号。
当比较两个版本时，从左到右依次比较它们的修订号。忽略每个修订号的前导零，直接比较修订号对应的整数值。如果其中一个版本没有足够的修订号，缺失部分默认补为0。
你需要根据以下规则返回比较结果：
version1 > version2，返回 1。version1 < version2，返回 -1。0。测试样例
样例1：
输入：
version1 = "0.1" , version2 = "1.1"
输出：-1
样例2：
输入：
version1 = "1.0.1" , version2 = "1"
输出：1
样例3：
输入：
version1 = "7.5.2.4" , version2 = "7.5.3"
输出：-1
样例4：
输入：
version1 = "1.0" , version2 = "1.0.0"
输出：0
def solution(version1, version2):
# 分割版本号
v1_parts = version1.split('.')
v2_parts = version2.split('.')
# 比较每个修订号
max_length = max(len(v1_parts), len(v2_parts))
for i in range(max_length):
# 获取修订号，如果不存在则使用0
v1_num = int(v1_parts[i]) if i < len(v1_parts) else 0
v2_num = int(v2_parts[i]) if i < len(v2_parts) else 0
if v1_num > v2_num:
return 1
elif v1_num < v2_num:
return -1
return 0 # 如果所有修订号都相等
# 测试用例
if __name__ == "__main__":
print(solution("0.1", "1.1") == -1) # 输出: -1
print(solution("1.0.1", "1") == 1) # 输出: 1
print(solution("7.5.2.4", "7.5.3") == -1) # 输出: -1
print(solution("1.0", "1.0.0") == 0) # 输出: 0
字符串字符类型排序问题
问题描述
小C 需要对一个字符串进行特殊排序，这个字符串只包含三种字符类型：字母（大小写）、数字和问号。要求你按照以下规则进行排序：
- 问号的原始位置必须保持不变。
- 数字的原始位置必须保持不变，但数字要按照从大到小排序。
- 字母的原始位置必须保持不变，但字母要按照字典序从小到大排序。
你需要编写一个程序，帮助小C实现这个字符串的排序功能。
测试样例
样例1：
输入：
inp = "12A?zc"
输出：'21A?cz'
样例2：
输入：
inp = "1Ad?z?t24"
输出：'4Ad?t?z21'
样例3：
输入：
inp = "???123??zxy?"
输出：'???321??xyz?'
def solution(inp):
# 1. 初始化容器
numbers = []
letters = []
question_marks = []
# 2. 遍历字符串，分类字符
for char in inp:
if char.isdigit():
numbers.append(char)
elif char.isalpha():
letters.append(char)
elif char == '?':
question_marks.append(char)
# 3. 排序数字和字母
numbers.sort(reverse=True) # 从大到小
letters.sort() # 从小到大
# 4. 使用迭代器为排序的数字和字母
number_iter = iter(numbers)
letter_iter = iter(letters)
# 5. 重建字符串
result = []
for char in inp:
if char.isdigit():
result.append(next(number_iter))
elif char.isalpha():
result.append(next(letter_iter))
else:
result.append(char) # '?'
return ''.join(result)
if __name__ == "__main__":
# 添加测试用例
print(solution("12A?zc") == "21A?cz")
print(solution("1Ad?z?t24") == "4Ad?t?z21")
print(solution("???123??zxy?") == "???321??xyz?")
最优硬币组合问题
问题描述
小C有多种不同面值的硬币，每种硬币的数量是无限的。他希望知道，如何使用最少数量的硬币，凑出给定的总金额N。小C对硬币的组合方式很感兴趣，但他更希望在满足总金额的同时，使用的硬币数量尽可能少。
例如：小C有三种硬币，面值分别为 1, 2, 5。他需要凑出总金额为 18。一种最优的方案是使用三个 5 面值的硬币，一个 2 面值的硬币和一个 1 面值的硬币，总共五个硬币。
测试样例
样例1：
输入：
coins = [1, 2, 5], amount = 18
输出：[5, 5, 5, 2, 1]
样例2：
输入：
coins = [1, 3, 4], amount = 6
输出：[3, 3]
样例3：
输入：
coins = [5], amount = 10
输出：[5, 5]
def solution(coins, amount):
# 初始化动态规划数组
dp = [float('inf')] * (amount + 1)
last_coin = [-1] * (amount + 1) # 用于记录使用的硬币
dp[0] = 0 # 0元需要0个硬币
# 填充 dp 数组
for i in range(1, amount + 1):
for c in coins:
if i - c >= 0 and dp[i - c] + 1 < dp[i]:
dp[i] = dp[i - c] + 1
last_coin[i] = c
# 如果 dp[amount] 仍为 inf，说明无法凑成该金额
if dp[amount] == float('inf'):
return [] # 无法凑成该金额
# 回溯以找出硬币组合
result = []
while amount > 0:
result.append(last_coin[amount])
amount -= last_coin[amount]
# 将结果按从大到小排序以确保输出顺序一致
result.sort(reverse=True)
return result
if __name__ == "__main__":
# Add your test cases here
print(solution([1, 2, 5], 18) == [5, 5, 5, 2, 1]) # True
print(solution([1, 3, 4], 6) == [3, 3]) # True
print(solution([5], 10) == [5, 5]) # True
最大战力值
问题描述
小F正在设计一款手游，游戏中的角色战力值需要根据一定规则来平衡，以提升玩家的游戏体验。现在游戏中有 n 个角色，编号从 0 到 n-1。为了保证平衡性，角色战力值需要遵循以下规则：
- 编号为
0的角色战力值初始为0。 - 每个角色的战力值必须是非负整数。
- 相邻角色的战力值差不能超过
1，即两个相邻角色的战力值差可以是0、+1或-1。
除此之外，游戏策划还为某些角色设定了最大战力值。这些限制通过若干数对给出，每一个数对 limit[i] = [index, maxPower]，表示编号为 index 的角色的战力值不能超过 maxPower。这些限定只会对编号不为 0 的角色生效。
你的任务是根据上述规则和限制，计算游戏中单个角色能达到的最大战力值。
测试样例
样例1：
输入：
n = 3 ,m = 2 ,limit = [[1, 3], [2, 2]]
输出：2
样例2：
输入：
n = 5 ,m = 3 ,limit = [[1, 1], [2, 3], [4, 3]]
输出：3
样例3：
输入：
n = 4 ,m = 1 ,limit = [[2, 2]]
输出：3
def solution(n, m, limit):
# 初始化最大战力值数组
power = [float('inf')] * n
power[0] = 0 # 角色 0 的战力值初始为 0
# 将限制应用到数组中
for index, maxPower in limit:
power[index] = min(power[index], maxPower)
# 前向遍历
for i in range(1, n):
power[i] = min(power[i], power[i - 1] + 1)
# 反向遍历
for i in range(n - 2, -1, -1):
power[i] = min(power[i], power[i + 1] + 1)
# 找到最大战力值
max_power = max(power[1:]) # 忽略角色 0
return max_power
if __name__ == "__main__":
# Add your test cases here
print(solution(3, 2, [[1, 3], [2, 2]]) == 2)
print(solution(5, 3, [[1, 1], [2, 3], [4, 3]]) == 3)
print(solution(4, 1, [[2, 2]]) == 3)
字符串chhc子串权值求和
问题描述
小M正在研究一个由字母'c'和'h'组成的字符串，他的任务是计算该字符串所有子串中，出现的子串"chhc"的总次数。我们定义一个字符串的权值为其包含"chhc"子串的数量。你的任务是帮助小M求出整个字符串中所有子串的权值之和。
测试样例
样例1：
输入：
s = "chhchhc"
输出：8
样例2：
输入：
s = "chhcchhcchhc"
输出：43
样例3：
输入：
s = "hhhh"
输出：0
def solution(s: str) -> int:
target = "chhc"
target_length = len(target)
n = len(s)
total_value = 0
# 查找所有 "chhc" 的起始位置
for i in range(n - target_length + 1):
if s[i:i + target_length] == target:
# 计算贡献
left_choices = i + 1 # 从0到i的所有起始位置选择
right_choices = n - (i + target_length) # 从i+4到n的所有结束位置选择
total_value += left_choices * (right_choices + 1) # +1因为包括结束位置本身
return total_value
if __name__ == '__main__':
print(solution("chhchhc") == 8) # 输出应为 8
print(solution("chhcchhcchhc") == 43) # 输出应为 43
print(solution("hhhh") == 0) # 输出应为 0
小C的外卖超时判断
小C点了一个外卖，并且急切地等待着骑手的送达。她想知道她的外卖是否超时了。
已知小C在时刻 t1 点了外卖，外卖平台上显示的预计送达时间为 t2，而实际送达时间为 t3。需要判断外卖是否超时。如果外卖超时，则输出 "Yes"；否则输出 "No"。
实际送达时间与预计送达时间在 2 小时之内。
测试样例
示例 1：
输入：
t1 = "18:00", t2 = "19:05", t3 = "19:05"
输出："No"
示例 2：
输入：
t1 = "23:00", t2 = "00:21", t3 = "00:23"
输出："Yes"
示例 3：
输入：
t1 = "23:05", t2 = "00:05", t3 = "23:58"
输出："No"
def time_to_minutes(time: str) -> int:
"""将时间字符串转换为分钟数"""
hours, minutes = map(int, time.split(':'))
return hours * 60 + minutes
def solution(t1: str, t2: str, t3: str) -> str:
# 将时间转换为分钟数
start_time = time_to_minutes(t1)
estimated_time = time_to_minutes(t2)
actual_time = time_to_minutes(t3)
# 处理跨天情况
if estimated_time < start_time:
estimated_time += 24 * 60
if actual_time < start_time:
actual_time += 24 * 60
# 判断是否超时
if actual_time > estimated_time:
return "Yes"
else:
return "No"
if __name__ == '__main__':
print(solution("18:00", "19:05", "19:05") == 'No')
print(solution("23:00", "00:21", "00:23") == 'Yes')
print(solution("23:05", "00:05", "23:58") == 'No')
小C的类二进制拼图
问题描述
小C发现了一种特殊的数字，称为类二进制数字，即仅由数字0和1组成的十进制数。例如，101和1100都是类二进制数字，而112和3001则不是。现在，小C手上有一个正整数n，他想知道最少需要多少个类二进制数字相加才能得到n。
测试样例
样例1：
输入：
n = "10101"
输出：1
样例2：
输入：
n = "212"
输出：2
样例3：
输入：
n = "1000000"
输出：1
样例4：
输入：
n = "123456789"
输出：9
样例5：
输入：
n = "9876543210"
输出：9
def solution(n: str) -> int:
# 找到每一位的最大数字
max_digit = max(n) # 找到字符串中的最大字符
return int(max_digit) # 返回最大字符转换为整数
if __name__ == '__main__':
print(solution("10101") == 1)
print(solution("212") == 2)
print(solution("1000000") == 1)
print(solution("123456789") == 9)
print(solution("9876543210") == 9)
小C的连续自然数乘积问题
问题描述
小S在学习素数因子的分解，她希望在[1,n][1,n]的范围内，找到一些连续的自然数，这些数的乘积最多包含kk个不同的素因子。你的任务是帮助小S找到可以取的连续自然数的最大长度。
连续的自然数指的是不能重复且相邻数的差为1的一组正整数，例如 [2, 3, 4, 5] 和 [5, 6, 7] 都是连续的取数。
测试样例
样例1：
输入：
n = 10,k = 3
输出：6
样例2：
输入：
n = 20,k = 5
输出：12
样例3：
输入：
n = 100,k = 4
输出：10
from collections import defaultdict
def prime_factors(x):
factors = set()
d = 2
while d * d <= x:
while (x % d) == 0:
factors.add(d)
x //= d
d += 1
if x > 1:
factors.add(x)
return factors
def solution(n: int, k: int) -> int:
left = 1
max_length = 0
factor_count = defaultdict(int) # 记录每个素因子的数量
for right in range(1, n + 1):
# 更新右边界的素因子
factors = prime_factors(right)
for factor in factors:
factor_count[factor] += 1
# 检查不同素因子的数量
while len(factor_count) > k:
# 移动左边界并更新素因子
left_factors = prime_factors(left)
for factor in left_factors:
factor_count[factor] -= 1
if factor_count[factor] == 0:
del factor_count[factor]
left += 1
# 计算当前窗口的长度
max_length = max(max_length, right - left + 1)
return max_length
if __name__ == "__main__":
print(solution(10, 3) == 6)
print(solution(20, 5) == 12)
print(solution(100, 4) == 10)
小F的寻找字符任务
问题描述
小F和他的朋友们围成了一个圈，他们每个人背上贴了一个字母，要么是A，要么是B。从第一个人开始计数，每当他遇到一个贴着字母A的人就计数一次。当他计数到第kk个A时，任务就结束了。你需要帮助小F计算一下，他总共需要数多少个人才能在第kk次遇到A后停止。保证至少有一个人背上贴的是A。
测试样例
样例1：
输入：
n = 3 ,k = 3 ,people = "AAB"
输出：4
样例2：
输入：
n = 3 ,k = 3 ,people = "BBA"
输出：9
样例3：
输入：
n = 5 ,k = 4 ,people = "ABABA"
输出：6
def solution(n: int, k: int, people: str) -> int:
count_A = 0 # 计数A的数量
total_count = 0 # 计数总人数
i = 0 # 当前人的索引
# 继续循环，直到遇到第k个A
while count_A < k:
if people[i % n] == 'A': # 使用模运算处理循环
count_A += 1 # 遇到A，计数
total_count += 1 # 计数总人数
i += 1 # 继续下一个人
return total_count
if __name__ == '__main__':
print(solution(3, 3, "AAB") == 4) # 预期输出是 4
print(solution(3, 3, "BBA") == 9) # 预期输出是 9
print(solution(5, 4, "ABABA") == 6) # 预期输出是 6
计算特定条件下的四元组数量
问题描述
小S正在处理一个数组，目标是找到满足特定条件的四元组数量。给定一个长度为n的数组a，他需要计算有多少四元组(i,j,k,l)(i,j,k,l)满足：a_i + a_j = a_k ⊕ a_l，其中 ⊕⊕ 表示按位异或，并且满足索引的条件 i < j < k < l。
由于答案可能非常大，所以你需要对 109+7109+7 取模后输出结果。
测试样例
样例1：
输入：
n = 5, a = [2, 3, 1, 5, 4]
输出：1
样例2：
输入：
n = 6, a = [1, 2, 3, 4, 5, 6]
输出：1
样例3：
输入：
n = 4, a = [4, 1, 3, 2]
输出：0
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):
if a[i] + a[j] == a[k] ^ a[l]:
count += 1
count %= MOD # 取模
return count
# 测试
if __name__ == '__main__':
print(solution(5, [2, 3, 1, 5, 4]) == 1) # 应该返回 True
print(solution(6, [1, 2, 3, 4, 5, 6]) == 1) # 应该返回 True
print(solution(4, [4, 1, 3, 2]) == 0) # 应该返回 True
二进制反码转换问题
问题描述
小C在学习二进制运算，他了解到每个非负整数都有其二进制表示。例如，整数 5 可以被表示为二进制 "101"，整数 11 可以被表示为二进制 "1011"，并且除了 N = 0 外，任何二进制表示中都不含前导零。
二进制的反码表示是将每个 1 变为 0，每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。现在小C想知道，给定一个十进制数 N，它的二进制反码对应的十进制数是多少。
测试样例
样例1：
输入：
N = 5
输出：2
样例2：
输入：
N = 10
输出：5
样例3：
输入：
N = 0
输出：1
def solution(N: int) -> int:
# 将 N 转换为二进制（去掉 '0b' 前缀）
binary_representation = bin(N)[2:]
# 生成反码
inverted_binary = ''.join('1' if bit == '0' else '0' for bit in binary_representation)
# 将反码转换回十进制
inverted_decimal = int(inverted_binary, 2)
return inverted_decimal
if __name__ == '__main__':
print(solution(N=5) == 2) # True
print(solution(N=10) == 5) # True
print(solution(N=0) == 1) # True
作者：R_yy
