华为被嘲，这是我见过比 sleep(6) 更狠的吐槽

本文链接：https://blog.youkuaiyun.com/weixin_33243821/article/details/140398694

华为被嘲

今天无意间在 Github 看到华为开源项目 huaweicloud-sdk-php-obs 中的最新 issue。

差点被当场笑死。

翻看历史，早在 2021 年的时候，就有 issue 指出「为什么朋友圈都在笑代码写得烂？」

至今该 issue 还处于 Open 状态，没有回应。

里面的评论也十分讽刺。

这不禁让人联想到两个月前，华为在发布会展示大模型文生图能力时，演示过程中被网友抓拍到的 time.sleep(6)。

之后很长一段时间，这都被程序员作为一个"优化梗"玩坏了：

真的，自那以后我就发现，程序员是最不惯着华为的群体。

即使华为后面在 5 月 16 日进行了澄清，这事情在程序员圈也没有停止发酵。

一堆新词被发明了出来，什么「确定性延迟」和「我进 OD 为的就是 sleep() 这块技术」的段子都是在那个时候被发明出来的 🤣🤣

...

回归主题。

来一道和「阿里」相关的算法题。

题目描述

平台：LeetCode

题号：1877

一个数对 (a,b) 的数对和等于 a + b。

最大数对和是一个数对数组中最大的数对和。

比方说，如果我们有数对 (1,5) ，(2,3) 和 (4,4)，最大数对和为 max(1+5, 2+3, 4+4) = max(6, 5, 8) = 8。

给你一个长度为偶数 n 的数组 nums，请你将 nums 中的元素分成 n / 2 个数对，使得：

nums 中每个元素恰好在一个数对中
且最大数对和的值最小

请你在最优数对划分的方案下，返回最小的最大数对和。

示例 1：

输入：nums = [3,5,2,3]

输出：7

解释：数组中的元素可以分为数对 (3,3) 和 (5,2) 。
最大数对和为 max(3+3, 5+2) = max(6, 7) = 7 。

示例 2：

输入：nums = [3,5,4,2,4,6]

输出：8

解释：数组中的元素可以分为数对 (3,5)，(4,4) 和 (6,2) 。
最大数对和为 max(3+5, 4+4, 6+2) = max(8, 8, 8) = 8 。

提示：

n 是偶数

基本分析 & 证明

直觉上，我们会认为「尽量让“较小数”和“较大数”组成数对，可以有效避免出现“较大数成对”的现象」。

我们来证明一下该猜想是否成立。

假定 nums 本身有序，由于我们要将 nums 拆分成 n / 2 个数对，根据猜想，我们得到的数对序列为：

「换句话说，构成答案的数对必然是较小数取自有序序列的左边，较大数取自有序序列的右边，且与数组中心对称」。

假设最大数对是，其中，记两者之和为。

反证法证明，不存在别的数对组合会比更优：

假设存在数对与进行调整使答案更优。

接下来分情况讨论：

调整为和：此时最大数对答案为，显然。我们要最小化最大数对和，因此该调整方案不会让答案更好；
调整为和：此时最大数对答案为。我们要最小化最大数对和，因此该调整方案不会让答案更好；

「上述分析可以归纳推理到每一个“非对称”的数对配对中。」

至此我们得证，将原本对称的数对调整为不对称的数对，不会使得答案更优，即贪心解可取得最优解。

贪心

对原数组 nums 进行排序，然后从一头一尾开始往中间组「数对」，取所有数对中的最大值即是答案。

Java 代码：

class Solution {
    public int minPairSum(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        int ans = nums[0] + nums[n - 1];
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            ans = Math.max(ans, nums[i] + nums[j]);
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int minPairSum(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        int ans = nums[0] + nums[n - 1];
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            ans = max(ans, nums[i] + nums[j]);
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def minPairSum(self, nums: List[int]) -> int:
        nums.sort()
        n = len(nums)
        ans = nums[0] + nums[n - 1]
        i, j = 0, n - 1
        while i < j:
            ans = max(ans, nums[i] + nums[j])
            i, j = i + 1, j - 1
        return ans

TypeScript 代码：

function minPairSum(nums: number[]): number {
    nums.sort((a, b) => a - b);
    let n = nums.length;
    let ans = nums[0] + nums[n - 1];
    for (let i = 0, j = n - 1; i < j; i++, j--) {
        ans = Math.max(ans, nums[i] + nums[j]);
    }
    return ans;
};