2023华为OD机试 (B卷)|200分 内存资源分配(C++ Java JavaScript Python)
题目描述
有一个简易内存池,内存按照大小粒度分类,每个粒度有若干个可用内存资源,用户会进行一系列内存申请,需要按需分配内存池中的资源,返回申请结果成功失败列表。
分配规则如下:
- ①分配的内存要大于等于内存的申请量,存在满足需求的内存就必须分配,优先分配粒度小的,但内存不能拆分使用;
②需要按申请顺序分配,先申请的先分配,有可用内存分配则申请结果为true;
③没有可用则返回false. 注意:不考虑内存释放
输入描述
输入为两行字符串 第一行为内存池资源列表,包含内存粒度信息数据,粒度数据间用逗号分割
- 一个粒度信息内用冒号分割,冒号前位内存粒度大小,冒号后为数量
- 资源列表不大于
1024
- 每个粒度的数量不大于
4096
第二行为申请列表,申请的内存大小间用逗号分割
- 申请列表不大于
100000
如
64:2, 128:1, 32:4, 1:128
50,36,64,128,127
输出描述
输出位内存池分配结果
如true,true,true, false ,false
用例
输入 | 64:2,128:1,32:4,1:128 50,36,64,128,127 |
---|---|
输出 | true, true,true,false,false |
说明 | 内存池资源包含:64K共2个,128K共1个,32共4个,1k共128个的内存资源;针对50,36,64,128,127的内存申请系列,分配内存一次是:64,64,128,NULL,NULL,第三次申请内存时已经将128分配出去,因此输出结果是:true,true,true,false,false |
Java
import java.util.*;
public class Main {
public static void main(String[] args) {
// 处理输入
Scanner scanner = new Scanner(System.in); // 创建一个Scanner对象,用于读取控制台的输入
String memoryInfo = scanner.next(); // 读取内存池资源列表
String applyList = scanner.next(); // 读取申请列表
// 内存信息
List<Integer> memoryList = new ArrayList<>(); // 创建一个ArrayList对象,用于存储内存池中可用的内存大小
List<String> memoryInfoList = new ArrayList<>(Arrays.asList(memoryInfo.split(","))); // 将内存池资源列表按逗号分隔,转换为ArrayList对象
for (String info : memoryInfoList) { // 遍历内存池资源列表
int colonIndex = info.indexOf(":"); // 找到冒号的位置
int size = Integer.parseInt(info.substring(0, colonIndex)); // 截取内存大小
int count = Integer.parseInt(info.substring(colonIndex + 1)); // 截取内存块数量
for (int i = 0; i < count; i++) { // 将内存块数量的内存大小添加到内存列表中
memoryList.add(size);
}
}
// 申请信息
List<Integer> applyMemoryList = new ArrayList<>(); // 创建一个ArrayList对象,用于存储申请的内存大小
List<String> applyListList = new ArrayList<>(Arrays.asList(applyList.split(","))); // 将申请列表按逗号分隔,转换为ArrayList对象
for (String apply : applyListList) { // 遍历申请列表
applyMemoryList.add(Integer.parseInt(apply)); // 将申请的内存大小添加到申请内存列表中
}
// 分配内存
List<Boolean> resultList = new ArrayList<>(); // 创建一个ArrayList对象,用于存储每个申请是否成功
for (int applyMemory : applyMemoryList) { // 遍历申请内存列表
boolean flag = false; // 定义一个标志位,用于标记是否成功分配内存
for (int i = 0; i < memoryList.size(); i++) { // 遍历内存列表
if (memoryList.get(i) >= applyMemory) { // 如果当前内存块的大小大于等于申请的内存大小
flag = true; // 标记成功分配内存
memoryList.remove(i); // 将当前内存块从内存列表中移除
break; // 跳出循环
}
}
resultList.add(flag); // 将是否成功分配内存的结果添加到结果列表中
}
// 输出结果
for (int i = 0; i < resultList.size(); i++) { // 遍历结果列表
System.out.print(resultList.get(i)); // 输出当前申请是否成功分配内存
if (i != resultList.size() - 1) { // 如果不是最后一个结果
System.out.print(","); // 输出逗号分隔符
}
}
}
}
Javascript
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
let memoryInfo, applyList;
rl.on('line', (input) => {
if (!memoryInfo) {
memoryInfo = input;
} else if (!applyList) {
applyList = input;
rl.close();
}
});
rl.on('close', () => {
// 处理输入
const memoryList = [];
const memoryInfoArr = memoryInfo.split(',');
for (let i = 0; i < memoryInfoArr.length; i++) {
const [sizeStr, countStr] = memoryInfoArr[i].split(':');
const size = parseInt(sizeStr);
const count = parseInt(countStr);
for (let j = 0; j < count; j++) {
memoryList.push(size);
}
}
// 申请信息
const applyMemoryList = applyList.split(',').map(Number);
// 分配内存
const resultList = [];
for (let i = 0; i < applyMemoryList.length; i++) {
let flag = false;
for (let j = 0; j < memoryList.length; j++) {
if (memoryList[j] >= applyMemoryList[i]) {
flag = true;
memoryList.splice(j, 1);
break;
}
}
resultList.push(flag);
}
// 输出结果
console.log(resultList.map((res) => res ? 'true' : 'false').join(','));
});
C++
#include
#include
#include
using namespace std;
int main() {
// 处理输入
string memoryInfo, applyList;
cin >> memoryInfo >> applyList;
// 内存信息
vector<int> memoryList;
stringstream ss(memoryInfo);
string info;
while (getline(ss, info, ',')) {
int colonIndex = info.find(":");
int size = stoi(info.substr(0, colonIndex));
int count = stoi(info.substr(colonIndex + 1));
for (int i = 0; i < count; i++) {
memoryList.push_back(size);
}
}
// 申请信息
vector<int> applyMemoryList;
stringstream ss2(applyList);
string apply;
while (getline(ss2, apply, ',')) {
applyMemoryList.push_back(stoi(apply));
}
// 分配内存
vector<bool> resultList;
for (int applyMemory : applyMemoryList) {
bool flag = false;
for (int i = 0; i < memoryList.size(); i++) {
if (memoryList[i] >= applyMemory) {
flag = true;
memoryList.erase(memoryList.begin() + i);
break;
}
}
resultList.push_back(flag);
}
// 输出结果
for (int i = 0; i < resultList.size(); i++) {
cout << (resultList[i] ? "true" : "false");
if (i != resultList.size() - 1) {
cout << ",";
}
}
return 0;
}
python
memoryInfo = input() # 读取内存池资源列表
applyList = input() # 读取申请列表
# 内存信息
memoryList = [] # 创建一个列表,用于存储内存池中可用的内存大小
memoryInfoList = memoryInfo.split(",") # 将内存池资源列表按逗号分隔,转换为列表
for info in memoryInfoList: # 遍历内存池资源列表
colonIndex = info.index(":") # 找到冒号的位置
size = int(info[:colonIndex]) # 截取内存大小
count = int(info[colonIndex + 1:]) # 截取内存块数量
for i in range(count): # 将内存块数量的内存大小添加到内存列表中
memoryList.append(size)
# 申请信息
applyMemoryList = [] # 创建一个列表,用于存储申请的内存大小
applyListList = applyList.split(",") # 将申请列表按逗号分隔,转换为列表
for apply in applyListList: # 遍历申请列表
applyMemoryList.append(int(apply)) # 将申请的内存大小添加到申请内存列表中
# 分配内存
resultList = [] # 创建一个列表,用于存储每个申请是否成功
for applyMemory in applyMemoryList: # 遍历申请内存列表
flag = False # 定义一个标志位,用于标记是否成功分配内存
for i in range(len(memoryList)): # 遍历内存列表
if memoryList[i] >= applyMemory: # 如果当前内存块的大小大于等于申请的内存大小
flag = True # 标记成功分配内存
memoryList.pop(i) # 将当前内存块从内存列表中移除
break # 跳出循环
resultList.append(flag) # 将是否成功分配内存的结果添加到结果列表中
# 输出结果
for i in range(len(resultList)): # 遍历结果列表
print(resultList[i], end='') # 输出当前申请是否成功分配内存
if i != len(resultList) - 1: # 如果不是最后一个结果
print(',', end='') # 输出逗号分隔符