这才多久，ChatGPT-4o 又被碾压了？

大模型皇位易主？

昨天，OpenAI 的竞争对手 Anthropic 发布了其最强大的 AI 模型：Claude 3.5 Sonnet。

目前，Claude 3.5 Sonnet 已经在 Claude.ai 和 Claude iOS 应用程序上免费提供。

据 Anthropic 号称，Claude 3.5 Sonnet 在阅读理解、推理、数学和编码等众多基准测试中，只有数学方面落后于 ChatGPT 4o。

还贴出了具体的对比数据：

除了发布了新版模型以外，Anthropic 还做了一些很讨好用户的用户体验优化，例如 "Artifacts" 功能。

所谓的 Artifacts 功能，是指当用户要求 Claude 生成代码片段、文本文档或网站设计等内容时，这些 Artifacts 会出现在他们对话旁边的专用窗口中。

相当于一个动态工作区，用户可以在其中实时查看、编辑和构建生成内容的实际效果。

...

当然了，想要在测试中赢过 ChatGPT 是相对容易的，几乎每隔一段时间，我们就会听到这样的新闻。

但想要在实际使用体验上超过 ChatGPT，是很难的。

大家感兴趣也可以体验一下，目前号称最强模型的 Claude 3.5 Sonnet：

https://claude.ai

...

回归主线。

来一道和「腾讯」相关的算法原题。

题目描述

平台：LeetCode

题号：658

给定一个排序好的数组 arr，两个整数 k 和 x ，从数组中找到最靠近 x（两数之差最小）的 k 个数。

返回的结果必须要是按升序排好的。

整数 a 比整数 b 更接近 x 需要满足：

|a - x| < |b - x| 或者
|a - x| == |b - x| 且 a < b

示例 1：

输入：arr = [1,2,3,4,5], k = 4, x = 3

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

示例 2：

输入：arr = [1,2,3,4,5], k = 4, x = -1

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

提示：

arr 按升序排列

二分 + 双指针

容易想到先通过「二分」找到与 x 差值最小的位置 idx，然后从 idx 开始使用「双指针」往两边进行拓展（初始化左端点，右端点），含义为范围内子数组为候选区间，不断根据两边界与 x 的差值关系进行扩充，直到候选区间包含 k 个数。

Java 代码：

class Solution {
    public List<Integer> findClosestElements(int[] arr, int k, int x) {
        int n = arr.length, l = 0, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid] <= x) l = mid;
            else r = mid - 1;
        }
        r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r;
        int i = r - 1, j = r + 1;
        while (j - i - 1 < k) {
            if (i >= 0 && j < n) {
                if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++;
                else i--;
            } else if (i >= 0) {
                i--;
            } else {
                j++;
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int p = i + 1; p <= j - 1; p++) ans.add(arr[p]);
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> findClosestElements(vector<int>& arr, int k, int x) {
        int n = arr.size(), l = 0, r = n - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (arr[mid] <= x) l = mid;
            else r = mid - 1;
        }
        r = (r + 1 < n && abs(arr[r + 1] - x) < abs(arr[r] - x)) ? r + 1 : r;
        int i = r - 1, j = r + 1;
        while (j - i - 1 < k) {
            if (i >= 0 && j < n) {
                if (abs(arr[j] - x) < abs(arr[i] - x)) j++;
                else i--;
            } else if (i >= 0) {
                i--;
            } else {
                j++;
            }
        }
        vector<int> ans;
        for (int p = i + 1; p <= j - 1; p++) ans.push_back(arr[p]);
        return ans;
    }
};

Python 代码：

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        n = len(arr)
        l, r = 0, n - 1
        while l < r:
            mid = l + r + 1 >> 1
            if arr[mid] <= x: l = mid
            else: r = mid - 1
        r = r + 1 if r + 1 < n and abs(arr[r + 1] - x) < abs(arr[r] - x) else r
        i, j = r - 1, r + 1
        while j - i - 1 < k:
            if i >= 0 and j < n:
                if abs(arr[j] - x) < abs(arr[i] - x):
                    j += 1
                else:
                    i -= 1
            elif i >= 0:
                i -= 1
            else:
                j += 1
        return arr[i + 1:j]

TypeScript 代码：

function findClosestElements(arr: number[], k: number, x: number): number[] {
    let n = arr.length, l = 0, r = n - 1
    while (l < r) {
        const mid = l + r + 1 >> 1
        if (arr[mid] <= x) l = mid
        else r = mid - 1
    }
    r = r + 1 < n && Math.abs(arr[r + 1] - x) < Math.abs(arr[r] - x) ? r + 1 : r
    let i = r - 1, j = r + 1
    while (j - i - 1 < k) {
        if (i >= 0 && j < n) {
            if (Math.abs(arr[j] - x) < Math.abs(arr[i] - x)) j++
            else i--
        } else if (i >= 0) {
            i--
        } else {
            j++
        }
    }
    return arr.slice(i + 1, j);
};