华为OD机试 - 简易内存池(Python/JS/C/C++ 2025 A卷 200分)

在这里插入图片描述

华为OD机试 2025A卷题库疯狂收录中,刷题点这里

专栏导读

本专栏收录于《华为OD机试真题(Java/Python/JS/C/C++)》

刷的越多,抽中的概率越大,私信哪吒,备注华为OD,加入华为OD刷题交流群,每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景,发现新题目,随时更新。

一、题目描述

请实现一个简易内存池,根据请求命令完成内存分配和释放。

内存池支持两种操作命令,REQUEST和RELEASE,其格式为:

1、REQUEST

请求的内存大小表示请求分配指定大小内存,如果分配成功,返回分配到的内存首地址;如果内存不足,或指定的大小为0,则输出error。

2、RELEASE

释放的内存首地址 表示释放掉之前分配的内存,释放成功无需输出,如果释放不存在的首地址则输出error。

注意:

1.内存池总大小为100字节。
2.内存池地址分配必须是连续内存,并优先从低地址分配。
3.内存释放后可被再次分配,已释放的内存在空闲时不能被二次释放。
4.不会释放已申请的内存块的中间地址。
5.释放操作只是针对首地址所对应的单个内存块进行操作,不会影响其它内存块。

二、输入描述

首行为整数N,表示操作命令的个数。

接下来的N行,每行将给出一个操作命令,操作命令和参数之间用“=”分割

三、输出描述

输出最后请求的内存的首地址。

如果位置已满,则输出-1。

样例:

2
REQUEST=10
REQUEST=20

输出样例:

0
10

四、解题思路

  1. 定义一个map,存储内存的分配情况(key:内存的首地址,value:内存的尾地址);
  2. 请求内存时
    • 如果map是空,放在首地址0处;
    • 如果map不为空,遍历已经存入的首地址;
      • 已经存入的首地址 - 第一个空闲区域的首地址 大于 请求的内存值;
      • 将当前请求的内存的首地址和内存的尾地址存入map;
      • 反之,重置前一个空闲区域的首地址;
    • 判断剩余内存是否可以容下当前请求值;
      • 如果可以容下,将当前请求的内存的首地址和内存的尾地址存入map;
      • 如果容不下,输出error;
  3. 释放内存时,将其首地址的key移除map;
  4. 最后输出最后一次请求的首地址。

注意:如果最后发起的命令是RELEASE,也是可以的,会返回最后一次REQUEST的首地址。

五、测试用例

1、输入

4
REQUEST=20
REQUEST=30
RELEASE=0
REQUEST=30

2、输出

50

3、说明

  • 第一次请求20
  • 第二请求30
  • 第三次释放首地址为0的内存
  • 第四次请求30,第一个空闲区域的首地址是0,但空闲长度只有20,放不下当前请求的地址,因此消耗剩余内存,输出最后一次请求的首地址为50。

在这里插入图片描述

4、再输入

6
REQUEST=20
REQUEST=30
RELEASE=0
REQUEST=30
REQUEST=10
REQUEST=10

5、再说明

  • 第一次请求20
  • 第二请求30
  • 第三次释放首地址为0的内存
  • 第四次请求30,第一个空闲区域的首地址是0,但空闲长度只有20,放不下当前请求的地址,因此消耗剩余内存。
  • 第五次请求10,第一个空闲区域的首地址是0,长度20,可以容下当前请求的内存10。
  • 第六次请求10,第一个空闲区域的首地址是10,长度10,可以容下当前请求的内存10。
  • 输出最后一次请求的首地址为10。

在这里插入图片描述

在这里插入图片描述

6、如果走后一次请求的是20,会怎么样呢?

在这里插入图片描述

六、Python算法源码

class MemoryManager:
    REQUEST = "REQUEST"
    RELEASE = "RELEASE"
    ERROR = "error"
    MAX = 100

    def __init__(self):
        self.memory_map = {}

    def main(self):
        try:
            # 操作命令的个数
            N = int(input().strip())
            # 每一行的操作命令和参数
            line_arr = [input().strip().split('=') for _ in range(N)]

            for command, value_str in line_arr:
                value = int(value_str)
                if command.startswith(self.REQUEST):  # 请求
                    # 非法输入(内存池总大小为100字节)
                    if value > self.MAX or value <= 0:
                        print(self.ERROR)
                        return
                    self.request(value)
                elif command.startswith(self.RELEASE):  # 释放
                    self.memory_map.pop(value, None)
                else:  # 非法输入
                    print(self.ERROR)
        except Exception as e:
            # 非法输入
            print(self.ERROR)

    def request(self, value):
        zero = 0
        before_head_address = 0

        if not self.memory_map:  # 如果memory_map是空,放在首地址0处
            self.memory_map[zero] = value
            print(zero)
        else:
            head_list = sorted(self.memory_map.keys())

            for requested_head in head_list:
                if requested_head - before_head_address >= value:
                    self.memory_map[before_head_address] = before_head_address + value
                    print(before_head_address)
                    return
                else:
                    before_head_address = self.memory_map[requested_head]

            if self.MAX - before_head_address >= value:
                self.memory_map[before_head_address] = before_head_address + value
                print(before_head_address)
            else:
                print("-1")


if __name__ == "__main__":
    MemoryManager().main()

七、JavaScript算法源码

class MemoryManager {
    constructor() {
        this.REQUEST = "REQUEST";
        this.RELEASE = "RELEASE";
        this.ERROR = "error";
        this.MAX = 100;
        this.memoryMap = new Map(); // 用于存储内存的分配情况
    }

    main() {
        try {
            const input = require('readline-sync');
            // 操作命令的个数
            const N = parseInt(input.question().trim());
            // 每一行的操作命令和参数
            const lineArr = [];
            for (let i = 0; i < N; i++) {
                lineArr.push(input.question().trim().split('='));
            }

            for (let i = 0; i < N; i++) {
                const [command, valueStr] = lineArr[i];
                const value = parseInt(valueStr);
                if (command.startsWith(this.REQUEST)) { // 请求
                    // 非法输入(内存池总大小为100字节)
                    if (value > this.MAX || value <= 0) {
                        console.log(this.ERROR);
                        return;
                    }
                    this.request(value);
                } else if (command.startsWith(this.RELEASE)) { // 释放
                    this.memoryMap.delete(value);
                } else { // 非法输入
                    console.log(this.ERROR);
                }
            }
        } catch (e) {
            // 非法输入
            console.log(this.ERROR);
        }
    }

    request(value) {
        let zero = 0;
        let beforeHeadAddress = 0;

        if (this.memoryMap.size === 0) { // 如果memoryMap是空,放在首地址0处
            this.memoryMap.set(zero, value);
            console.log(zero);
        } else {
            const headList = Array.from(this.memoryMap.keys()).sort((a, b) => a - b);

            for (let requestedHead of headList) {
                if (requestedHead - beforeHeadAddress >= value) {
                    this.memoryMap.set(beforeHeadAddress, beforeHeadAddress + value);
                    console.log(beforeHeadAddress);
                    return;
                } else {
                    beforeHeadAddress = this.memoryMap.get(requestedHead);
                }
            }

            if (this.MAX - beforeHeadAddress >= value) {
                this.memoryMap.set(beforeHeadAddress, beforeHeadAddress + value);
                console.log(beforeHeadAddress);
            } else {
                console.log("-1");
            }
        }
    }
}

// 执行内存管理器
const memoryManager = new MemoryManager();
memoryManager.main();

八、C算法源码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define REQUEST "REQUEST"
#define RELEASE "RELEASE"
#define ERROR "error"
#define MAX 100

typedef struct MemoryBlock {
    int start;
    int end;
    struct MemoryBlock* next;
} MemoryBlock;

MemoryBlock* head = NULL;

void request(int value);
void release(int value);
void print_error();
void print_memory_address(int address);

int main() {
    int N;
    scanf("%d", &N);

    for (int i = 0; i < N; i++) {
        char command[10];
        int value;
        scanf("%s=%d", command, &value);

        if (strncmp(command, REQUEST, strlen(REQUEST)) == 0) {
            if (value > MAX || value <= 0) {
                print_error();
                return 0;
            }
            request(value);
        } else if (strncmp(command, RELEASE, strlen(RELEASE)) == 0) {
            release(value);
        } else {
            print_error();
            return 0;
        }
    }

    return 0;
}

void request(int value) {
    int beforeHeadAddress = 0;

    if (head == NULL) {
        // 如果链表为空,放在首地址0处
        MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
        newBlock->start = 0;
        newBlock->end = value;
        newBlock->next = NULL;
        head = newBlock;
        print_memory_address(0);
    } else {
        MemoryBlock* current = head;
        MemoryBlock* prev = NULL;

        while (current != NULL) {
            if (current->start - beforeHeadAddress >= value) {
                MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
                newBlock->start = beforeHeadAddress;
                newBlock->end = beforeHeadAddress + value;
                newBlock->next = current;

                if (prev == NULL) {
                    head = newBlock;
                } else {
                    prev->next = newBlock;
                }
                print_memory_address(newBlock->start);
                return;
            }
            beforeHeadAddress = current->end;
            prev = current;
            current = current->next;
        }

        if (MAX - beforeHeadAddress >= value) {
            MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
            newBlock->start = beforeHeadAddress;
            newBlock->end = beforeHeadAddress + value;
            newBlock->next = NULL;
            prev->next = newBlock;
            print_memory_address(newBlock->start);
        } else {
            print_memory_address(-1);
        }
    }
}

void release(int value) {
    MemoryBlock* current = head;
    MemoryBlock* prev = NULL;

    while (current != NULL) {
        if (current->start == value) {
            if (prev == NULL) {
                head = current->next;
            } else {
                prev->next = current->next;
            }
            free(current);
            return;
        }
        prev = current;
        current = current->next;
    }
}

void print_error() {
    printf("%s\n", ERROR);
}

void print_memory_address(int address) {
    printf("%d\n", address);
}

九、C++算法源码

#include <iostream>
#include <map>
#include <string>

using namespace std;

class MemoryManager {
public:
    static const int MAX = 100;
    const string REQUEST = "REQUEST";
    const string RELEASE = "RELEASE";
    const string ERROR = "error";

    void main() {
        try {
            int N;
            cin >> N;
            cin.ignore(); // 忽略换行符

            string lineArr[N][2];
            for (int i = 0; i < N; ++i) {
                string command;
                getline(cin, command);

                size_t pos = command.find('=');
                if (pos != string::npos) {
                    lineArr[i][0] = command.substr(0, pos);
                    lineArr[i][1] = command.substr(pos + 1);
                }
            }

            for (int i = 0; i < N; ++i) {
                int value = stoi(lineArr[i][1]);
                if (lineArr[i][0].find(REQUEST) == 0) { // 请求
                    if (value > MAX || value <= 0) {
                        cout << ERROR << endl;
                        return;
                    }
                    request(value);
                } else if (lineArr[i][0].find(RELEASE) == 0) { // 释放
                    memoryMap.erase(value);
                } else { // 非法输入
                    cout << ERROR << endl;
                }
            }
        } catch (...) {
            // 非法输入
            cout << ERROR << endl;
        }
    }

private:
    map<int, int> memoryMap;

    void request(int value) {
        int beforeHeadAddress = 0;

        if (memoryMap.empty()) { // 如果memoryMap是空,放在首地址0处
            memoryMap[0] = value;
            cout << 0 << endl;
        } else {
            for (auto it = memoryMap.begin(); it != memoryMap.end(); ++it) {
                if (it->first - beforeHeadAddress >= value) {
                    memoryMap[beforeHeadAddress] = beforeHeadAddress + value;
                    cout << beforeHeadAddress << endl;
                    return;
                }
                beforeHeadAddress = it->second;
            }

            if (MAX - beforeHeadAddress >= value) {
                memoryMap[beforeHeadAddress] = beforeHeadAddress + value;
                cout << beforeHeadAddress << endl;
            } else {
                cout << "-1" << endl;
            }
        }
    }
};

int main() {
    MemoryManager memoryManager;
    memoryManager.main();
    return 0;
}


🏆本文收录于,华为OD机试真题(Python/JS/C/C++)

刷的越多,抽中的概率越大,私信哪吒,备注华为OD,加入华为OD刷题交流群,每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景,发现新题目,随时更新。

在这里插入图片描述

<think>嗯,用户想找关于红日靶场的IT内容或技术资料,特别是涉及IT安全、靶场平台、漏洞测和网络安全的信息。首先,我需要回顾一下用户提供的引用内容,看看哪些部可以应用到这里。引用[1]提到红日靶场模拟了国内企业的实际业务场景,包括CMS、漏洞管理、域管理等,这应该和用户的需求相关。引用[2]和[3]别涉及Weblogic漏洞利用和具体的工具使用,比如Redis、MDUT等,还有CVE漏洞的利用。引用[4]是关于日志清理的命令,可能和渗透后的痕迹清理有关。 用户的问题是要寻找相关的技术资料,可能需要包括靶场的设计理念、具体漏洞的利用方法、使用的工具以及渗透测的步骤。我需要把这些信息整合起来,按照用户要求的格式,点回答,结构清晰,同时生成相关问题。 接下来要确保回答中提到的技术点都有对应的引用来源,比如红日靶场的环境设计引用[1],Weblogic漏洞引用[2],工具使用引用[3],日志清理引用[4]。同时,需要检查用户提供的系统级指令,比如数学表达式使用$...$,但在这个问题中可能用不上,不过要留意是否有数学相关的内容。用户还要求生成相关问题,这部需要围绕红日靶场的技术点来提问,比如渗透测流程、漏洞利用方法、工具使用等。 另外,要确保回答用中文,并且引用标识自然添加在段落末尾。例如,在提到靶场设计时引用[^1],提到Weblogic漏洞时引用[^2],工具使用引用[^3],日志清理引用[^4]。需要避免使用Markdown格式,但用户给的示例中使用了代码块,可能需要在回答中包含代码示例,比如日志清理的命令,这时候用反引号包裹。 最后,生成的相关问题要围绕红日靶场的不同方面,比如环境搭建、漏洞析、工具使用、渗透技巧等,确保问题具有针对性和实用性,帮助用户进一步探索相关内容。</think>### 红日靶场 IT安全技术解析 红日靶场作为国内领先的渗透测训练平台,其核心价值在于**真实企业场景模拟**和**ATT&CK攻防框架实践**。以下是关键技术要点: #### 1. 靶场环境架构设计 - **多维度渗透路径**:覆盖Web应用层(如CMS漏洞)、中间件层(WebLogic漏洞)、内网域控等层级 - **典型漏洞集成**- **典型漏洞集成**: - **WebLogic反序列化漏洞**(CVE-2016-0638):通过`WebLogicTool`扫描验证,利用工具直接执行系统命令 ```bash java -jar WebLogicTool.jar -t CVE-2016-0638 -u http://target:7001 ``` - **Laravel远程代码执行**(CVE-2021-3129):使用专用EXP工具实现RCE #### 2. 渗透测技术栈 - **工具链配置**: - 数据库利用:`Redis Insight`管理Redis数据库,`MDUT`进行多数据库联合攻击 - 后门维持:`Godzilla v2.96`和`中国蚁剑`双通道Webshell管理 - 横向移动:`cdk`检测容器环境漏洞,`mimikatz`抓取域凭据 - **痕迹清理技术**: ```powershell wevtutil cl security # 清除安全日志 wevtutil cl system # 清除系统日志 ``` 需配合`meterpreter`的`clearev`模块实现自动化清理 #### 3. 域渗透专项训练 - **黄金票据伪造**:通过域控服务器获取KRBTGT账户的NTLM哈希 - **SMB中继攻击**:利用Responder工具捕获Net-NTLMv2哈希 - **GPO策略利用**:通过组策略部署恶意计划任务
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值