华为OD机试 2024E卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
一、题目描述
某块业务芯片最小容量单位为 1.25G，总容量为 M*1.25G，对该芯片资源编号为 1，2，… M。
该芯片支持 3 种不同的配置，分别为 A、B、C.
- 配置 A: 占用容量为 1.25 * 1 = 1.25G
- 配置 B: 占用容量为 1.25* 2 = 2.5G
- 配置 C: 占用容量为 1.258 = 10G
某块板卡上集成了 N 块上述芯片，对芯片编号为 1，2，…，N，各个芯片之间彼此独立，不能跨芯片占用资源.给定板卡上芯片数量 N、每块芯片容量 M、用户按次序配置后，请输出芯片资源占用情况，保证消耗的芯片数量最少。
资源分配规则: 按照芯片编号从小到大分配所需资源，芯片上资源如果被占用标记为 1，没有被占用标记为 0 用户配置序列:用户配置是按次序依次配置到芯片中，如果用户配置序列种某个配置超过了芯片总容量，丢弃该配置，继续遍历用户后续配置。
二、输入描述
- M：每块芯片容量为 M*1.25G，取值范围为: 1~256
- N：每块板卡包含芯片数量，取值范围为 1~32
- 用户配置序列：例如 ACABA，长度不超过 1000
三、输出描述
板卡上每块芯片的占用情况。
备注：
用户配置是按次序依次配置到芯片中，如果用户配置序列种某个配置超过了芯片总容量，丢弃该配置，继续遍历用户后续配置。
四、题目解析
本题输出比较难以理解，我这里以用例 1 解释一下：
1、输入
8
2
ACABA
2、输出
11111000
11111111
用例 1 的前两行输入表示：
板卡上有 N=2 个芯片，而每个芯片有 8 个单位容量，因此对应如下：
00000000
00000000
其中每个 0 代表一个单位容量，而一个芯片有 8 单位容量，因此第一排 8 个 0 代表一个芯片的总容量，第二排 8 个 0 代表另一个芯片的总容量理解了这个，本题就不难了。
四、解题思路
- 首先读取输入的芯片容量 M、芯片数量 N 和用户配置序列；
- 创建一个长度为 N 的数组 boardCard，用于表示每块芯片的剩余容量；初始时，每块芯片的剩余容量为 M * 1.25；
- 创建一个哈希表 dict，用于存储配置与占用容量的对应关系；其中，‘A’ 对应占用容量为 1.25，‘B’ 对应占用容量为 2.5，‘C’ 对应占用容量为 10；
- 遍历用户配置序列，对于每个配置，执行以下操作：
- 计算当前配置对应的占用容量 need；
- 遍历芯片数组 boardCard，找到第一个剩余容量大于等于 need 的芯片，并将其剩余容量减去 need；
- 如果没有找到满足条件的芯片，则丢弃该配置；
- 遍历芯片数组 boardCard，对于每块芯片，输出占用情况；将剩余容量转换为对应的占用情况字符串，其中 1 表示占用，0 表示未占用；
- 输出每块芯片的占用情况；
五、Python算法源码
# 导入必要的库
import sys
def allocate_resources(M, N, config_sequence):
# 定义每种配置占用的容量（单位为1.25G）
config_size = {
'A': 1, # A配置占用1.25G
'B': 2, # B配置占用2.5G
'C': 8 # C配置占用10G
}
# 初始化每个芯片的剩余容量，初始为M
remaining = [M for _ in range(N)]
# 初始化每个芯片的资源占用情况，使用二进制字符串表示
allocation = ['0' * M for _ in range(N)]
# 遍历每一个配置
for config in config_sequence:
size = config_size.get(config, 0) # 获取配置的大小
allocated = False # 标记是否成功分配
# 尝试将配置分配到最小编号的芯片
for i in range(N):
if remaining[i] >= size:
# 更新剩余容量
remaining[i] -= size
# 更新资源占用情况
allocation[i] = '1' * size + allocation[i][size:]
allocated = True
break # 成功分配后退出循环
if not allocated:
# 如果所有芯片都无法分配，丢弃该配置
continue
# 打印每个芯片的资源占用情况
for chip_allocation in allocation:
print(chip_allocation)
# 主函数，处理输入输出
if __name__ == "__main__":
# 读取每块芯片的容量M
M = int(sys.stdin.readline())
# 读取芯片数量N
N = int(sys.stdin.readline())
# 读取用户配置序列
config_sequence = sys.stdin.readline().strip()
# 调用资源分配函数
allocate_resources(M, N, config_sequence)
六、JavaScript算法源码
// 定义资源分配函数
function allocateResources(M, N, configSequence) {
// 定义每种配置占用的容量（单位为1.25G）
const configSize = {
'A': 1, // A配置占用1.25G
'B': 2, // B配置占用2.5G
'C': 8 // C配置占用10G
};
// 初始化每个芯片的剩余容量，初始为M
let remaining = Array(N).fill(M);
// 初始化每个芯片的资源占用情况，使用二进制字符串表示
let allocation = Array(N).fill('0'.repeat(M));
// 遍历每一个配置
for (let config of configSequence) {
let size = configSize[config] || 0; // 获取配置的大小
let allocated = false; // 标记是否成功分配
// 尝试将配置分配到最小编号的芯片
for (let i = 0; i < N; i++) {
if (remaining[i] >= size) {
// 更新剩余容量
remaining[i] -= size;
// 更新资源占用情况
allocation[i] = '1'.repeat(size) + allocation[i].substring(size);
allocated = true;
break; // 成功分配后退出循环
}
}
if (!allocated) {
// 如果所有芯片都无法分配，丢弃该配置
continue;
}
}
// 打印每个芯片的资源占用情况
for (let chipAllocation of allocation) {
console.log(chipAllocation);
}
}
// 示例用法，读取输入并调用函数
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
let input = [];
rl.on('line', function(line){
input.push(line);
}).on('close', function(){
const M = parseInt(input[0]);
const N = parseInt(input[1]);
const configSequence = input[2].trim();
allocateResources(M, N, configSequence);
process.exit(0);
});
七、C算法源码
#include <stdio.h>
#include <string.h>
// 定义最大芯片数量和配置序列长度
#define MAX_N 32
#define MAX_SEQUENCE 1000
int main() {
int M, N;
char config_sequence[MAX_SEQUENCE + 1];
// 读取每块芯片的容量M
scanf("%d", &M);
// 读取芯片数量N
scanf("%d", &N);
// 读取用户配置序列
scanf("%s", config_sequence);
// 定义每种配置占用的容量（单位为1.25G）
int config_size[256] = {0}; // 初始化为0
config_size['A'] = 1; // A配置占用1.25G
config_size['B'] = 2; // B配置占用2.5G
config_size['C'] = 8; // C配置占用10G
// 初始化每个芯片的剩余容量，初始为M
int remaining[MAX_N];
for(int i = 0; i < N; i++) {
remaining[i] = M;
}
// 初始化每个芯片的资源占用情况，使用字符数组表示
char allocation[MAX_N][MAX_SEQUENCE + 1];
for(int i = 0; i < N; i++) {
memset(allocation[i], '0', M);
allocation[i][M] = '\0'; // 添加字符串结束符
}
// 遍历每一个配置
int len = strlen(config_sequence);
for(int i = 0; i < len; i++) {
char config = config_sequence[i];
int size = config_size[(int)config]; // 获取配置的大小
int allocated = 0; // 标记是否成功分配
// 尝试将配置分配到最小编号的芯片
for(int j = 0; j < N; j++) {
if(remaining[j] >= size) {
// 更新剩余容量
remaining[j] -= size;
// 更新资源占用情况
for(int k = 0; k < size; k++) {
if(k < M) {
allocation[j][k] = '1';
}
}
allocated = 1;
break; // 成功分配后退出循环
}
}
if(!allocated){
// 如果所有芯片都无法分配，丢弃该配置
continue;
}
}
// 打印每个芯片的资源占用情况
for(int i = 0; i < N; i++) {
printf("%s\n", allocation[i]);
}
return 0;
}
八、C++算法源码
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(){
int M, N;
string config_sequence;
// 读取每块芯片的容量M
cin >> M;
// 读取芯片数量N
cin >> N;
// 读取用户配置序列
cin >> config_sequence;
// 定义每种配置占用的容量（单位为1.25G）
int config_size[256] = {0}; // 初始化为0
config_size['A'] = 1; // A配置占用1.25G
config_size['B'] = 2; // B配置占用2.5G
config_size['C'] = 8; // C配置占用10G
// 初始化每个芯片的剩余容量，初始为M
vector<int> remaining(N, M);
// 初始化每个芯片的资源占用情况，使用字符串表示
vector<string> allocation(N, string(M, '0'));
// 遍历每一个配置
for(char config : config_sequence){
int size = config_size[(int)config]; // 获取配置的大小
bool allocated = false; // 标记是否成功分配
// 尝试将配置分配到最小编号的芯片
for(int i = 0; i < N; i++){
if(remaining[i] >= size){
// 更新剩余容量
remaining[i] -= size;
// 更新资源占用情况
for(int j = 0; j < size && j < M; j++){
allocation[i][j] = '1';
}
allocated = true;
break; // 成功分配后退出循环
}
}
if(!allocated){
// 如果所有芯片都无法分配，丢弃该配置
continue;
}
}
// 打印每个芯片的资源占用情况
for(auto &chip_allocation : allocation){
cout << chip_allocation << endl;
}
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。
