华为OD机试真题2024（Python/C-D/100分/1-10）

1.寻找身高相近的小朋友

思路：直接对数组排序。

难度：⭐

height, num = map(int, input().split())
arr = list(map(int, input().split()))

arr_sort = sorted(arr,key=lambda x:(abs(x-height),x))
print(' '.join(map(str, arr_sort)))

2.围棋的气

思路：对数组的二次重构，构建求围棋的气的函数包括固有要求和限制条件。

难度：⭐⭐⭐

black = list(map(int, input().split()))
white = list(map(int, input().split()))

# 将围棋以坐标的格式构建成[[0,5],[8,9],[9,10]]
black_zb = []
white_zb = []
for i in range(0, len(black), 2):
    black_zb.append(black[i:i + 2])
for i in range(0, len(black), 2):
    white_zb.append(white[i:i + 2])


# 定义找气的函数
def weiqi_qi(zb, blacka_and_white):
    num_qi = 0
    list_qi = []
    for i in zb:
        x, y = i
        # 设定限制条件，符合条件的进入到气数组，不符合的排除
        for qi in [x + 1, y], [x - 1, y], [x, y + 1], [x, y - 1]:
            if -1 < qi[0] < 19 and -1 < qi[1] < 19:
                if qi not in blacka_and_white and qi not in list_qi:
                    num_qi += 1
                    list_qi.append(qi)
    return num_qi


print(weiqi_qi(black_zb, black_zb + white_zb))
print(weiqi_qi(white_zb, black_zb + white_zb))

3.用连续自然数之和来表达整数

思路：双指针，逐个元素尝试，如输入为n时，第一个指针指向1，第二个指针开始1+2+...，如果中途有的话就记录下来，没有的话第一个指针指向下一个数2，第二个开始2+3+...，继续判断，直至第一个指针移动完毕为止。（目前代码不完全符合要求，公式法可能更简单）

难度：⭐⭐⭐

n = int(input())
print(f'{n}={n}')

cnt = 1
for i in range(1,n):
    arr = []
    n_sum = i
    for j in range(i+1,n):
        n_sum += j
        if n_sum == n:
            for t in range(i,j+1):
                arr.append(t)
                arr1 = '+'.join(str(x) for x in arr)
            cnt += 1
            print(f'{n}={arr1}')
print(f'Result:{cnt}')

4.开源项目热榜

思路：在输入数据的时候直接将每一项的分数和每一项的加权进行加权计算出总分，以[名字,总分]的形式进行排序。

难度：⭐⭐

n = int(input())
arr = list(map(int, input().split()))
open_source = []
for i in range(n):
    temp = list(input().split())
    name = temp[0]
    # 注意这里输入的是str格式，需要转换为int格式
    score = int(temp[1])*arr[0]+int(temp[2])*arr[1]+int(temp[3])*arr[2]+int(temp[4])*arr[3]+int(temp[5])*arr[4]
    open_source.append([name, score])

# 因为score需要从大到小排序，而name需要从小到大排序，所以在score前加负号了
final = sorted(open_source, key=lambda x:(-x[1],x[0]))

for i in final:
    print(i[0])

5.API集群负载统计

思路：将‘/’作为分割符对输入进行分割，注意分割后的元素有无空格。遍历所有元素，找出元素中的目标位置是否与输入匹配。

难度：⭐⭐

n = int(input())

arr = []
for i in range(n):
    temp = input().split('/')
    # 以/作为分隔符之后，temp的第一个元素是空格，所以不要
    arr.append(temp[1:])

target_num, target_name = input().split()
target_num = int(target_num)

cnt = 0
for i in arr:
    # 如果当前地址的长度小于目标位置，那么当前地址不符合要求
    if len(i) >= target_num:
        # 判断当前地址的目标位置是否为目标字符
        if i[target_num - 1] == target_name:
            cnt += 1

print(cnt)

6.整数对最小和

思路：用两次循环将两个数组中的元素进行逐个相加，再对要求的n个和再次相加。

难度：⭐✨

arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))
n = int(input())

# 因为数组中第一个元素是这个数组实际可用的元素的个数，用不上，去除
arr1 = arr1[1:]
arr2 = arr2[1:]

# 用两次循环将数组1和数组2的各个元素之和添加进新的数组中
arr = []
for i in arr1:
    for j in arr2:
        arr.append(i+j)

# 从小打到排序，并求出前n个和的总和
arr.sort()
print(sum(arr[:n]))

7.素数之积

思路：设定判别素数的函数，然后在循环中判别分解的两个数是否为素数。

难度：⭐⭐✨

n = int(input())

# 判别分解出来的数是否为素数
def sushu(x):
    for i in range(2, x):
        if x % i == 0:
            return False
    return True


result = []
f = True
for i in range(2, n):
    if n % i == 0:
        # 求得第一个分解的数，并判断其是否为素数
        one = n // i
        if sushu(one):
            # 如果第一个分解的数是素数，求另一个分解的数，并判断其是否为素数
            ano = n // one
            if sushu(ano):
                # 如果另一个分解的数也是素数，那么即找到两个分解的素数，标志位取反，结束循环
                result.append([one, ano])
                f = False
                break

# 查看标志位，如果标志位不变（True），那么就是没有找到，输出-1 -1。如果标志位变了（False），那么就找到了，先排序再按要求输出
if not f:
    result = result[0]
    result.sort()
    print(' '.join(map(str, result)))
else:
    print(-1, -1)

8.CPU算力分配

思路：对A、B组服务器进行循环，逐一判别当前的元素是否符合要求。

难度：⭐⭐

n1, n2 = map(int, input().split())
arr1 = list(map(int, input().split()))
arr2 = list(map(int, input().split()))

# 由于要对A组服务器的CPU算力尽量小，所以先排序，循环就会从小到大进行
arr1.sort()
# 标志位，用于判断是否退出循环
f = True
# 两次循环，逐个判断是否符合要求
for i in arr1:
    for j in arr2:
        # 判断依据：A组服务器的i算力CPU与B组服务器的j算力CPU交换，算力是否相等
        if sum(arr1) - i + j == sum(arr2) - j + i:
            print(f'{i} {j}')
            # 如果找到可交换的CPU，标志位取反，即退出循环
            f = False
            break
    if not f:
        break

9.最大坐标值

思路：用一个数组记录各个时刻下的位置，并且根据幸运数的大小设定不同的移动策略。

难度：⭐⭐

n = int(input())
m = int(input())
arr = list(map(int, input().split()))

# 定义一个循环过程中的位置数组，并设定起点为0
max_loc = [0]
for i in arr:
    # 判断当前数字是否为幸运数，如果是幸运数，那么当前的位置为在上一个位置根据幸运数的正负而多进或多退一步
    if i == m:
        if i < 0:
            loc = max_loc[-1] + i -1
            max_loc.append(loc)
        elif i > 0:
            loc = max_loc[-1] + i + 1
            max_loc.append(loc)
        else:
            loc = max_loc[-1] + i
            max_loc.append(loc)
    # 如果不是幸运数，那么当前的位置为在上一个位置的基础上移动
    else:
        loc = max_loc[-1] + i
        max_loc.append(loc)

# 题目要求的是在循环过程中最大的坐标位置
print(max(max_loc))

10.寻找最富裕的小家庭

思路：创建字典将父节点和子节点的内容以键值对的形式保存并排序。

难度：⭐⭐

n = int(input())
arr = list(map(int, input().split()))

# 用字典去记录键-值关系是处理父节点和子节点问题中比较直接的方法
dic1 = {}
for i in range(n-1):
    temp = list(map(int, input().split()))
    # 如果字典中没有这个键，那么创建键值对，键为当前父节点，值为当前父节点和子节点对应的财富
    if temp[0] not in dic1.keys():
        dic1[temp[0]] = arr[temp[0]-1] + arr[temp[1]-1]
    # 如果字典中已有这个键，那么只需在原有的值上加即可
    else:
        dic1[temp[0]] += arr[temp[1] - 1]

# 字典的排序一般为其items()，格式为键x[0]，值x[1]
dic1_max = sorted(dic1.items(), key=lambda x:(-x[1],x[0]))
print(dic1_max[0][1])