刷了3个月的华为OD算法题，刷出感觉了，如洁柔般丝滑，文末送《漫画算法2：小灰的算法进阶》

在这里插入图片描述

- 一、考研二战，入职华为，反向调剂电子科大深圳
- 下面分享一道2023 B卷朋友抽中题简易内存池：
- 二、题目描述
- 三、输入描述
- 四、输出描述
- - 样例：
  - 输出样例：
- 五、解题思路
- 六、Java算法源码
- 七、效果展示
- - 1、输入
  - 2、输出
  - 3、说明
  - 4、再输入
  - 5、再说明
  - 6、如果走后一次请求的是20，会怎么样呢？
- 八、漫画算法2：小灰的算法进阶
- - 参与方式

大家好，我是哪吒。

最近一直在刷华为OD机试的算法题，坚持一天三道题的节奏，已经三个多月了，刷了270多道题，刚开始也有过想放弃的想法，刷一道卡一道，一道题要用1小时，因为太菜了吗？哎，一言难尽

随着时间的推移，感觉自己慢慢上道了，一道题用不上1个小时了，哈哈，这就是进步嘛

一、考研二战，入职华为，反向调剂电子科大深圳

不经意间在网上看到一个帖子《考研二战，入职华为，反向调剂电子科大深圳》，写的真不错，分享给大家。

加入华为OD后，给我的感觉比想象中，或者说比网上大部分的说法都要好。

我觉得在这里能学到很多东西，毕竟是大公司，平台也大，能接触到的牛人也多。

我觉得一个初来乍到的应届本科生受到歧视也正常，周围都是名校硕博，作为一个新人我没有任何理由骄傲。技不如人甘拜下风，虚心一点好好学习也是好的。

另外，我觉得无论是校招进华为正式，还是社招进华为od，我感觉没有想象中区别那么明显。

技术岗还是靠实力说话。我们的od员工和正式员工办公上没有一点差别，甚至我们组的美本的正式员工第一个月都不知道我们之间有什么区别。

我的本科同班同学校招进华为的也搞不懂我工号和他们正式员工工号的区别。

我的od同事有7年的ios开发经验，是从隔壁某个体面的硬件大厂跳槽过来的，因为工作经验丰富，反而成为了我和一个正式员工（应届）的老师。

我相信以他的实力，一年期满很快就能完成转正。即便转正名额给他而不给我，我也服气的。

我觉得在华为有一个巨大的优势，就是信息上的优势。

毕竟是在华为，了解到的资讯都是第一手的，很多消息非常通畅。

比方说我之前在学校完全不能理解大公司是怎么招人的，而在这里通过别人的只言片语，能对这个流程有个初步的理解感受。

包括下文中我提到了解非全硕士的过程，华为这个平台也给我提供了第一手的信息。

对于我的朋友，行业外的肯定不会认可我的本科，但是我直接笼统地说我在华为工作，外行便会肃然起敬。

而行业内的人我稍微解释一下他们也能理解，行业内还是看你的技术的，我还是非常肯定我自己的专业实力的。

并且行业内也知道我的本科杭州电子科技大学是华为目标院校，可以直接华为校招成为正式员工的。

比方说我这个工作除了签协议是和德科公司签的以外，别的部分都挺完美的了：是软件开发的技术岗、华为核心部分、利于项目经验积累、待遇不错。

毕竟我就是正儿八经的华为的社招，错过了校招的正式招聘时间才只能和德科签合同的。

反正对于我来说，每个人要找到适合自己的，找到自己的需求。需要什么，就去拿什么。入职的这一个月见识到了很多东西，收获颇丰，进步巨大。每天都在不停地自我更新中，感觉很好。

关于华为od，网上诟病最多的就是转正华为正式员工部分了。甚至我曾经做过hr的表姐都告诫我，“千万别去华为od，因为od永远不可以转正。”

我多方打听，包括反复跟招我的人确定转正情况。对方答复说我们部门有30%的转正率。我也通过其他不可能跟招我的人有联系的人确认了下，确认这个部门的转正率确实是30%。这才让我足够信任他们。

然后我在本科学校杭电的校内群里联系了两个华为od的校友，他们都是入职一年就获得了转正资格。我觉得他们是利益相关者，所以他们的话只能信一半。

我的核心想法是，我来华为就是来提升进步的，既然有转正机会，那么我就应该进去试试。如果我没法转正，那么我应该华为校招的正式岗位也过不了。

如果放弃这个offer去别的公司，如海康。几年之后我大概率还是要跳槽来华为，那么既然华为的低端社招=od，那么我跳槽华为也只能当od。

下面分享一道2023 B卷朋友抽中题简易内存池：

二、题目描述

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

内存池支持两种操作命令，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

五、解题思路

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

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

六、Java算法源码

package com.guor.od;

import java.util.*;

public class OdTest03 {

    static final String REQUEST = "REQUEST";
    static final String RELEASE = "RELEASE";
    static final String ERROR = "error";
    static final int MAX = 100;

    public static void main(String[] args) {
        try {
            Scanner sc = new Scanner(System.in);
            // 操作命令的个数
            int N = Integer.parseInt(sc.nextLine());
            // 每一行的操作命令和参数
            String[][] lineArr = new String[N][2];
            // 接下来的N行，每行将给出一个操作命令，操作命令和参数之间用“=”分割
            for (int i = 0; i < N; i++) {
                lineArr[i] = sc.nextLine().split("=");
            }

            for (int i = 0; i < N; i++) {
                // 内存大小
                int value = Integer.parseInt(lineArr[i][1]);
                if (lineArr[i][0].startsWith(REQUEST)) {// 请求
                    // 非法输入（内存池总大小为100字节）
                    if (value > MAX || value <= 0) {
                        System.out.println(ERROR);
                        return;
                    }
                    request(value);
                } else if (lineArr[i][0].startsWith(RELEASE)) {// 释放
                    map.remove(value);
                } else {// 非法输入
                    System.out.println(ERROR);
                }
            }
        } catch (Exception e) {
            // 非法输入
            System.out.println(ERROR);
        }
    }

    /**
     * 存储内存的分配情况
     * key：内存的首地址
     * value：内存的尾地址
     */
    static Map<Integer, Integer> map = new TreeMap<>();

    /**
     * 请求内存
     * @value：大小
     */
    public static void request(int value) {
        int zero = 0;
        // 前一个空闲区域的首地址
        int beforeHeadAddress = 0;

        // 如果map是空，放在首地址0处
        if (map.isEmpty()) {
            map.put(zero, value);
        } else {
            // 已经存入的首地址
            List<Integer> headList = new ArrayList<>(map.keySet());
            // 已经存入的首地址
            for (Integer requestedHead : headList) {
                // 已经存入的首地址 - 第一个空闲区域的首地址 大于 请求的内存值
                if (requestedHead - beforeHeadAddress >= value) {
                    /**
                     * beforeHeadAddress：内存的首地址
                     * beforeHeadAddress + value：内存的尾地址
                     */
                    map.put(beforeHeadAddress, beforeHeadAddress + value);
                } else {
                    // 前一个空闲区域的首地址
                    beforeHeadAddress = map.get(requestedHead);
                }
            }
            // 判断剩余内存是否可以容下当前请求值
            if (MAX - beforeHeadAddress >= value) {
                map.put(beforeHeadAddress, beforeHeadAddress + value);
            } else {
                // 如果位置已满，则输出-1。
                System.out.println("-1");
            }
        }
        System.out.println(beforeHeadAddress);
    }
}