冒雨上班，公司没了，又一家神仙公司撤出

本文主要是介绍冒雨上班，公司没了，又一家神仙公司撤出，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

伤心 IBM

上周五（8月23号），在 IBM 工作的同学还在正常上下班，突然发现访问权限被收回了。

后来消息被多方证实，IBM 中国的所有研发和测试岗位的权限均被收回，没有一点的征兆或信号，不少同学当时还正在加班。

涉及的员工主要集中在 IBM 中国开发中心（CDL）与 IBM 中国系统中心（CSL），这两个部门是 IBM 在中国的重要研发与测试基地。

一时间，这些研发和测试的小伙伴，都在通讯软件上被移除，也无法通过 VPN 访问公司内网，仅保留了邮件功能，而之所以还保留邮件功能，是因为要通知周一举行全员会议，公布某些显而易见的事情。

经过了忐忑不安的周末，时间来到周一（8月26号），不少同学冒雨赶到公司，参加全员会议，但这全员会议不是大家想象中的那种演讲大会堂，而仅仅是线上会议。在宣布完「China Club 要关闭」这一艰难决定后，会议便被切断，整个会议过程时长 3 分钟，你如果凑巧离开了电脑屏幕，去了趟卫生间的话，回来便会发现会议已结束。

IBM 中国已有 40 年的历史，不少老员工参与完这一全员会议后，表示“太羞辱人了，连个客气的感谢贡献都没有”。

但也有一些清醒的老员工表示，这早就有心理准备了，不只是因为周五被回收权限，而是前几年内网就曾流行过一句话：“IBM 是家伟大的公司，但 IBM China 不是”。

又一家养老厂（神仙公司）没落了，这无疑是个坏消息，但好在是所有被裁员工，都可以拿到 n+3 的补偿，算是不幸中的万幸。

至于 IBM 中国被一锅端的原因？

真要细究，其实也不算平地惊雷，早在去年一月，IBM 就在全国范围内裁员 3900 人，而同年的晚些时候，IBM 宣布停止招聘，表示要用人工智能期待近 8000 个职位。

这些都是可以查得到的公开数据，但你要说这些是不是主导关闭整个 IBM 中国的原因？我看未必。

毕竟今年 IBM 的财报业绩都不错，在刚过去的 7 月份，全球员工还因此多放了两天假。

因此，我更愿意相信另一个不在水面上的原因：随着 IBM 的新 CEO 阿尔温德·克里希纳（2020 年加入）在公司的声望越来越高，IBM 正逐步增加印度的投资，包括持续加大在印度的招聘力度，IBM 中国的撤出，更多单纯是高层的个人决策。

...

回归主题。

来一道和「外企」相关的题目。

题目描述

平台：LeetCode

题号：1282

有 n 个人被分成数量未知的组。每个人都被标记为一个从 0 到 n-1 的唯一 ID 。

给定一个整数数组 groupSizes，其中 groupSizes[i] 是第 i 个人所在的组的大小。例如，如果 groupSizes[1] = 3，则第 1 个人必须位于大小为 3 的组中。

返回一个组列表，使每个人 i 都在一个大小为 groupSizes[i] 的组中。

每个人应该恰好只出现在一个组中，并且每个人必须在一个组中。如果有多个答案，返回其中任何一个。可以保证给定输入至少有一个有效的解。

示例 1：

输入：groupSizes = [3,3,3,3,3,1,3]

输出：[[5],[0,1,2],[3,4,6]]

解释：
第一组是 [5]，大小为 1，groupSizes[5] = 1。
第二组是 [0,1,2]，大小为 3，groupSizes[0] = groupSizes[1] = groupSizes[2] = 3。
第三组是 [3,4,6]，大小为 3，groupSizes[3] = groupSizes[4] = groupSizes[6] = 3。 
其他可能的解决方案有 [[2,1,6],[5],[0,4,3]] 和 [[5],[0,6,2],[4,3,1]]。

示例 2：

输入：groupSizes = [2,1,3,3,3,2]

输出：[[1],[0,5],[2,3,4]]

提示：

哈希表 + 构造

答案确保有解，可直接进行构造：「假设组大小为的元素有个，则将这个元素按照个一组进行划分」。

具体的，我们可以使用哈希表 map 记录当前组大小为 x 的数组容器 cur。即组大小数值为 key，对应容器引用为 value。

从前往后处理每个，若 x 不在 map 或 map[x] 大小为 x，起一个新的组存入 map 和 ans 中，然后每次都将 i 存入到 map[x] 当中即可。

Java 代码：

class Solution {
    public List<List<Integer>> groupThePeople(int[] groupSizes) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        List<List<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < groupSizes.length; i++) {
            int x = groupSizes[i];
            if (!map.containsKey(x) || map.get(x).size() == x) {
                List<Integer> cur = new ArrayList<>();
                map.put(x, cur);
                ans.add(cur);
            }
            map.get(x).add(i);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
        unordered_map<int, vector<int>> map;
        vector<vector<int>> ans;
        for (int i = 0; i < groupSizes.size(); i++) {
            int x = groupSizes[i];
            map[x].push_back(i); 
            if (map[x].size() == x) {
                ans.push_back(map[x]);
                map[x].clear();
            }
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
        mapping = {}
        ans = []
        for i, x in enumerate(groupSizes):
            if x not in mapping or len(mapping[x]) == x:
                cur = []
                mapping[x] = cur
                ans.append(cur)
            mapping[x].append(i)
        return ans

Typescript 代码：

function groupThePeople(groupSizes: number[]): number[][] {
    const map = new Map<number, Array<number>>();
    const ans = new Array<Array<number>>();
    for (let i = 0; i < groupSizes.length; i++) {
        const x = groupSizes[i];
        if (!map.has(x) || map.get(x).length == x) {
            const cur = new Array<number>();
            map.set(x, cur);
            ans.push(cur);
        }
        map.get(x).push(i);
    }
    return ans;
};