2023华为OD机试 (B卷)|200分 内存资源分配(C++ Java JavaScript Python)

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='') # 输出逗号分隔符

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值