DeepSeek线上面试，没抗住压力面。。

宫水三叶的刷题日记

发布于 2025-02-19 12:39:06

37300

代码可运行

文章被收录于专栏：宫水三叶的刷题日记宫水三叶的刷题日记

运行总次数：0

代码可运行

DeepSeek 面经

年前，DeepSeek 冲击波还没进入白热化的时候，我们就写了 DeepSeek 这家公司的薪资水平。

最近，DeepSeek 的招聘职位，从 37 个缩减到 27 个。

或许是年后招聘人员重新编辑了在招岗位，又或许是有一批新天才加入了 DeepSeek。

虽然已经看过 DeepSeek 的在招岗位和薪资，但相信不少读者还是十分好奇：DeepSeek 的招聘流程到底是怎么样的？跟互联网传统的三面四面一样吗？

就在昨天，一位去年五月份参加过 DeepSeek 线上面试的应聘者分享了他的经历。

这位应聘者是一位 211、985 高校的应届博士生，在校期间也参与过不少企业的大型项目，但在面对 DeepSeek 面试过程中提及的那些深入且具有挑战性的问题时，仍然感到不少难度。

用他对 DeepSeek 的评价原话来说就是：

❝在我所经历过的互联网公司中，DeepSeek 是唯一一家会根据应聘者的专业背景量身定制编程题目的公司。 ❞

那可不，人家 DeepSeek 可是做大模型的，输入应聘者的相关信息，用 DeepSeek 直接生成量身定制的问题，那就是分分钟的事儿。

想要进 DeepSeek，通过 DeepSeek AI 的面试只是第一步

除了面试内容的深度和广度，这位招聘者还提到当时 DeepSeek 面试流程是「面试官连续 3 个小时高强度的提问」。

这其实就是我们常说的"压力面"，通过这种面试来模拟实际工作中可能遇到的压力情景，目的是考察应聘者是否能在紧张或高压的工作条件下保持冷静、有效沟通和解决问题的能力。

专业水平过关是前提，还得反应够快，承压能力强。

这也好理解，DeepSeek 是一个高度年轻化和本土化的团队，人数规模一直控制在 150 人以内，不设 KPI 考核，内部完全扁平化，每位算法人员都能直接和梁文锋交流。不像大厂，将任务极致细化，在职员工只需要负责好自己的一环即可。DeepSeek 的规模，决定了其人员负重更重，容错空间更少。因此在人员选择上，此类优秀的"小公司"肯定要比大厂要更严格。

对此，你怎么看？在你的求职经历中，有经过类似的压力面吗？欢迎评论区交流。

...

回归主题。

来一道经典校招算法题。

题目描述

平台：LeetCode

题号：1447

给你一个整数 n ，请你返回所有

到

之间（不包括

和

）满足分母小于等于 n 的最简分数。

分数可以以任意顺序返回。

示例 1：

输入：n = 2

输出：["1/2"]

解释："1/2" 是唯一一个分母小于等于 2 的最简分数。

示例 2：

输入：n = 3

输出：["1/2","1/3","2/3"]

示例 3：

输入：n = 4

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

解释："2/4" 不是最简分数，因为它可以化简为 "1/2" 。

示例 4：

输入：n = 1

输出：[]

提示：

1 <= n <= 100

数论

数据范围为

100

且数值大小在

(0, 1)

之间，因此枚举「分子 + 分母」的

O(n^2)

做法是可接受的。

于是问题转化为：如何快速判断两个数组成的分数是否为最简（即判断两个数的最大公约数是否为

）。

快速求得

和

的最大公约数的主要方式有两种 :「更相减损法」和「欧几里得算法」，其中「欧几里得算法」的递归实现最为好写，复杂度为

O(\log{(a + b)})

，在绝大多数的情况下适用，只有在需要实现高精度时，才会考虑使用「更相减损法」。

而 stein 算法则是没有必要掌握的。

Java 代码（欧几里得算法）：

class Solution {
    int gcd(int a, int b) { // 欧几里得算法
        return b == 0 ? a : gcd(b, a % b);
    }
    public List<String> simplifiedFractions(int n) {
        List<String> ans = new ArrayList<>();
        for (int i = 1; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (gcd(i, j) == 1) ans.add(i + "/" + j);
            }
        }
        return ans;
    }
}

C++ 代码（欧几里得算法）：

class Solution {
public:
    int gcd(int a, int b) { // 欧几里得算法
        return b == 0 ? a : gcd(b, a % b); 
    }
    vector<string> simplifiedFractions(int n) {
        vector<string> ans;
        for (int i = 1; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (gcd(i, j) == 1) ans.push_back(to_string(i) + "/" + to_string(j));
            }
        }
        return ans;
    }
};

Python 代码（欧几里得算法）：

class Solution:
    def gcd(self, a: int, b: int) -> int:  # 欧几里得算法
        return a if b == 0 else self.gcd(b, a % b)

    def simplifiedFractions(self, n: int) -> List[str]:
        ans = []
        for i in range(1, n + 1):
            for j in range(i + 1, n + 1):
                if self.gcd(i, j) == 1:
                    ans.append(f"{i}/{j}")
        return ans

TypeScript 代码（欧几里得算法）：

function gcd(a: number, b: number): number { // 欧几里得算法
    return b == 0 ? a : gcd(b, a % b);
}
function simplifiedFractions(n: number): string[] {
    const ans = [];
    for (let i = 1; i < n; i++) {
        for (let j = i + 1; j <= n; j++) {
            if (gcd(i, j) === 1) ans.push(`${i}/${j}`);
        }
    }
    return ans;
};

Java 代码（更相减损法）：

class Solution {
    int gcd(int a, int b) { // 更相减损法
        while (true) {
            if (a > b) a -= b;
            else if (a < b) b -= a;
            else return a;
        }
    }
    public List<String> simplifiedFractions(int n) {
        List<String> ans = new ArrayList<>();
        for (int i = 1; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (gcd(i, j) == 1) ans.add(i + "/" + j);
            }
        }
        return ans;
    }
}

Java 代码（stein）：

class Solution {
    int gcd(int a, int b) { // stein
        if (a == 0 || b == 0) return Math.max(a, b);
        if (a % 2 == 0 && b % 2 == 0) return 2 * gcd(a >> 1, b >> 1);
        else if (a % 2 == 0) return gcd(a >> 1, b);
        else if (b % 2 == 0) return gcd(a, b >> 1);
        else return gcd(Math.abs(a - b), Math.min(a, b));
    }
    public List<String> simplifiedFractions(int n) {
        List<String> ans = new ArrayList<>();
        for (int i = 1; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                if (gcd(i, j) == 1) ans.add(i + "/" + j);
            }
        }
        return ans;
    }
}