题目描述

某公司研发了一款高性能AI处理器。每台物理设备具备8颗AI处理器，编号分别为0、1、2、3、4、5、6、7。

编号0-3的处理器处于同一个链路中，编号4-7的处理器处于另外一个链路中，不通链路中的处理器不能通信。如下图所示：

现给定服务器可用的处理器编号数组array，以及任务申请的处理器数量num，找出符合下列亲和性调度原则的芯片组合。

如果不存在符合要求的组合，则返回空列表。

亲和性调度原则：

• 如果申请处理器个数为1，则选择同一链路，剩余可用的处理器数量为1个的最佳，其次是剩余3个的为次佳，然后是剩余2个，最后是剩余4个。
• 如果申请处理器个数为2，则选择同一链路剩余可用的处理器数量2个的为最佳，其次是剩余4个，最后是剩余3个。
• 如果申请处理器个数为4，则必须选择同一链路剩余可用的处理器数量为4个。
• 如果申请处理器个数为8，则申请节点所有8个处理器。

提示：

1. 任务申请的处理器数量只能是1、2、4、8。
2. 编号0-3的处理器处于一个链路，编号4-7的处理器处于另外一个链路。
3. 处理器编号唯一，且不存在相同编号处理器。

输入描述

输入包含可用的处理器编号数组array，以及任务申请的处理器数量num两个部分。

第一行为array，第二行为num。例如：

[0, 1, 4, 5, 6, 7]
1

表示当前编号为0、1、4、5、6、7的处理器可用。任务申请1个处理器。

• 0 <= array.length <= 8
• 0 <= array[i] <= 7
• num in [1, 2, 4, 8]

输出描述

输出为组合列表，当array=[0，1，4，5，6，7]，num=1 时，输出为[[0], [1]]。

测试样例1

输入

[0, 1, 4, 5, 6, 7]
1

输出

[[0], [1]]

说明

根据第一条亲和性调度原则，在剩余两个处理器的链路（0, 1, 2, 3）中选择处理器。

由于只有0和1可用，则返回任意一颗处理器即可。

测试样例2

输入

[0, 1, 4, 5, 6, 7]
4

输出

[[4, 5, 6, 7]]

说明

根据第三条亲和性调度原则，必须选择同一链路剩余可用的处理器数量为4个的环

Python代码解析

def find_processor_combination(array, num):
    # 统计每个链路中可用的处理器数量
    link0_count = sum(1 for x in array if x < 4)
    link1_count = len(array) - link0_count

    # 根据请求的处理器数量选择最佳组合
    if num == 1:
        # 选择同一链路剩余1个的最佳，其次是剩余3个的为次佳，然后是剩余2个，最后是剩余4个
        if link0_count == 1:
            return [[array[0]]]  # 假设array中第一个元素是剩余1个的链路中的处理器
        elif link0_count == 3:
            return [[x] for x in array if x < 4]
        elif link0_count == 2:
            return [[x] for x in array if x < 4]
        elif link1_count == 1:
            return [[array[0]]]  # 假设array中第一个元素是剩余1个的链路中的处理器
        elif link1_count == 3:
            return [[x] for x in array if x >= 4]
        elif link1_count == 2:
            return [[x] for x in array if x >= 4]
        else:
            return []  # 没有合适的处理器
    elif num == 2:
        # 选择同一链路剩余2个的为最佳，其次是剩余4个，最后是剩余3个
        if link0_count == 2:
            return [[array[0], array[1]]]  # 假设array中前两个元素是剩余2个的链路中的处理器
        elif link0_count == 4:
            return [[x] for x in array if x < 4]
        elif link1_count == 2:
            return [[array[0], array[1]]]  # 假设array中前两个元素是剩余2个的链路中的处理器
        elif link1_count == 4:
            return [[x] for x in array if x >= 4]
        else:
            return []  # 没有合适的处理器
    elif num == 4:
        # 必须选择同一链路剩余4个的
        if link0_count == 4:
            return [[x for x in array if x < 4]]
        elif link1_count == 4:
            return [[x for x in array if x >= 4]]
        else:
            return []  # 没有合适的处理器
    elif num == 8:
        # 申请所有8个处理器
        return [array]
    else:
        return []  # 非法的num值


# 测试样例1
array1 = [0, 1, 4, 5, 6, 7]
num1 = 1
print(find_processor_combination(array1, num1))


# 测试样例2
array2 = [0, 1, 4, 5, 6, 7]
num2 = 4
print(find_processor_combination(array2, num2))