手记

Grok 3与DeepSeek R1深度对比:谁更强?

大家都知道DeepSeek R1这款模型,这是一个来自中国的开源AI,在网上火了一把。

DeepSeek最大的优势是它免费且开源,并且能够与OpenAI的收费模型,例如o1,抗衡。

然后,在2月16日,埃隆·马斯克宣布了Grok 3,称它为“地球上最聪明的AI”

但Grok 3与我们免费的模型DeepSeek R1相比,情况如何呢?这让我产生了好奇心,于是决定来测试一下Grok 3在编程逻辑推理数学创意写作等方面的对比,与DeepSeek R1的表现对比一下。

让我们看看到底围绕这个 Grok 3 的所有炒作是不是都是空穴来风。

我还分享了我对于每个模型在各种任务中的看法以及它们的表现,我测试了我创建的一系列提示。

TL;DR

如果你想直接跳到结论部分,这里有一个快速总结如下,对比DeepSeek R1和Grok 3的发现:

  • 推理:DeepSeek R1 和 Grok 3 模型在处理推理问题上的表现差不多。

  • 编码:Grok 3 比 DeepSeek R1 强很多,代码写得好多了。

  • 创意写作方面:两款模型在创意写作方面都表现得很好。相比之下,DeepSeek 这个模型很出名,但我更喜欢 Grok 3。
Grok 3 AI 模型简介说明

Grok 3 是来自 xAI 的最新语言模型,其比之前提升了10倍的计算能力。它包括了如 深度查找 这样的工具,用于逐步推理的工具,以及 大脑增强模式 用于处理复杂任务的工具。

目前,Grok 3 模型处于测试版,但它真的比 DeepSeek R1 模型好很多吗?但我们会在这篇文章的最后给出答案。

根据xAI团队在发布活动上分享的官方基准测试,Grok 3,似乎是一款游戏规则改变者,在几乎所有的基准测试中都超越了所有竞争对手。

此处省略

DeepSeek R1和Grok 3.

我使用了Chatbot Arena 来同时测试这些模型,因为这是一直以来唯一一个值得信赖的第三方网站,可以用来测试早期的 Grok 3 模型。

推理难题

ℹ️ 在这里,我们将检查模型的推理能力。

1. 玩俄罗斯轮盘赌

我们不妨从一个有趣的问题开始吧。

你正在玩俄式轮盘赌,用的是一把六腔手枪。你的对手往里面装了五发子弹,对着自己扣动扳机,但枪膛是空的。他给你一个选择,让他在对着你扣动扳机之前是否再旋转一次枪膛。他要不要再旋转一次?

  • Grok 3 的回复:

  • DeepSeek R1 的回答

最终结论:两个模型都正确地回答了问题,并且给出了合理的解释。✅

2. 奥运兄弟姐妹运动员

我是两位奥运运动员的姐姐,但她们不是我的亲姐妹。但是这两位运动员不是我的姐妹。这是可能的吗?

  • 来自 Grok 3 的回复

  • DeepSeek R1 的回答:

最终结论:在这里,两个模型都正确地回答了问题,并给出了正确的解释。✅

3. 找出那个撒谎的人

前两个问题相当直接。我们用一个稍微有点难的问题来结束这个推理测验吧。

你遇到了三个人:哈里斯、安东尼和迈克尔。哈里斯说:“我们三个里至少有一个在说谎。”安东尼说:“哈里斯在说谎。”迈克尔说:“安东尼说的是真的。”看看谁在骗人,谁说的是真话。

  • Grok 3 的回答

来看看Grok 3模型如何解决撒谎问题的第二部分

这里,Grok 3 进行了详尽的推理,针对每一种情况,一步一步拆解问题来支持其结论。

  • DeepSeek R1 的回复如下

最终结论:两个模型都正确地回答了这个问题✅,我觉得Grok 3模型的推理很突出。

小结:

由此可以看出,这两个模型都具有很强的推理能力,因为它们都正确回答了我所有的推理问题,。不过,在某些方面,Grok 3 的推理能力在某些情况下似乎超过了 R1。

数学

💁 看了两个模型对推理题的回答后,我觉得它们也应该能解决数学题。

从一个简单的问题先开始,看看他们怎么样。

1. 列车上的乘客数量

火车上原来有一些人。到了第一个车站,19个人下车了,17个人上车了。现在火车上有63个人。最初火车上有多少人呢?

  • Grok 3:回应

  • DeepSeek R1 的回复,

这是Deepseek R1模型给出的关于火车上人数问题的解答。

最终结果:两个模型采用了类似的方法,得到了正确的答案。✅

2. 素数定理的近似值

小于 $10^8$ 的质数有多少?

  • Grok 3 的回答

  • DeepSeek R1:
    回答:


Deepseek R1模型回答


回答由Deepseek R1模型提供

最终结论:两个模型都运用了素数定理,但DeepSeek R1模型的答案偏离了~1K,而Grok 3则偏离了~20K。因此,DeepSeek R1 ✅胜过Grok 3 ❌。

3. 数元音,然后求幂

这绝对是模型最难攻克的问题。它是一个对大模型非常有名的问题进行了稍微修改的版本,带有数学元素:"计算草莓里有多少个'r' "

计算 $(x - 14)^{10}$,这里的 $x$ 就是答案里元音数量。

  • Grok 3 的回复:
    为了解决这个问题,我们需要计算 \\((x - 14)^{10}\\),其中 \\(x\\) 是答案中元音字母的数量。这是一个自引用问题,我们需要找到一个答案,使得答案中的元音字母数量与表达式中的 \\(x\\) 相匹配。

    ### 步骤 1:定义问题
    - 设 \\(y = (x - 14)^{10}\\),其中 \\(x\\) 是 \\(y\\) 中元音字母的数量。
    - 元音字母包括 "a"、"e"、"i"、"o"、"u"(我们只考虑小写字母,除非另有特别说明)。
    - 我们需要找到一个 \\(y\\),使得 \\(y\\) 中的元音字母数量等于 \\(x\\),并且 \\(y = (x - 14)^{10}\\)。

    ### 步骤 2:尝试和错误的方法
    由于 \\(x\\) 是元音字母的数量,并且元音字母是非负整数,因此 \\(x \\geq 0\\)。然而,为了使表达式有意义,\\(x\\) 应当使 \\((x - 14)^{10}\\) 的结果中的元音字母数量等于 \\(x\\)。

    让我们尝试不同的 \\(x\\) 值并计算 \\(y\\),检查 \\(y\\) 中的元音字母数量。

    #### 情况 1:\\(x = 16\\)
    - \\(y = (16 - 14)^{10} = 2^{10} = 1024\\)。
    - 将 \\(y\\) 写作中文数字表述: "一千零二十四"。
    - 计算 "一千零二十四" 中的元音字母:
      - o(1),e(1),i(1),u(1),a(1),o(2) → 共 6 个元音字母。
    - \\(x = 16\\),然而 \\(y\\) 中的元音字母数量是 6,因此 \\(16 \\neq 6\\)。这个答案不成立。

    #### 情况 2:\\(x = 18\\)
    - \\(y = (18 - 14)^{10} = 4^{10}\\)。
    - \\(4^5 = 1024\\),因此 \\(4^{10} = (4^5)^2 = 1024^2\\)。
    - \\(1024^2 = 1,048,576\\)。
    - 将 \\(y\\) 写作中文数字表述: "一百四万八千五百七十六"。
    - 计算元音字母:
      - o(1),e(1),i(1),i(2),o(2),a(1),o(3),u(1),a(2),e(2),u(2),e(3),i(3) → 共 13 个元音字母。
    - \\(x = 18\\),然而 \\(y\\) 中的元音字母数量是 13,因此 \\(18 \\neq 13\\)。这个答案不成立。

    #### 情况 3:\\(x = 15\\)
    - \\(y = (15 - 14)^{10} = 1^{10} = 1\\)。
    - 将 \\(y\\) 写作中文数字表述: "一"。
    - 计算 "一" 中的元音字母: **o**n**e** → 共 2 个元音字母。
    - \\(x = 15\\),然而 \\(y\\) 中的元音字母数量是 2,因此 \\(15 \\neq 2\\)。这个答案不成立。

    #### 情况 4:\\(x = 17\\)
    - \\(y = (17 - 14)^{10} = 3^{10}\\)。
    - \\(3^5 = 243\\),因此 \\(3^{10} = (3^5)^2 = 243^2\\)。
    - \\(243^2 = 59,049\\)。
    - 将 \\(y\\) 写作中文数字表述: "五万九千零四十九"。
    - 计算元音字母:
      - i(1),i(2),e(1),o(1),u(1),a(1),i(3),e(2) → 共 8 个元音字母。
    - \\(x = 17\\),然而 \\(y\\) 中的元音字母数量是 8,因此 \\(17 \\neq 8\\)。这个答案不成立。

    ### 步骤 3:寻找规律
    让我们总结一下目前为止的结果:
    - \\(x = 14\\),\\(y = 0\\),元音字母 = 2。
    - \\(x = 15\\),\\(y = 1\\),元音字母 = 2。
    - \\(x = 16\\),\\(y = 1024\\),元音字母 = 6。
    - \\(x = 17\\),\\(y = 59,049\\),元音字母 = 8。
    - \\(x = 18\\),\\(y = 1,048,576\\),元音字母 = 13。

    看起来随着 \\(x\\) 的增加,\\(y\\) 的增长呈指数级(因为它是一次 \\(x - 14\\) 的 10 次方),而 \\(y\\) 中的元音字母数量也在增加,但并不总是等于 \\(x\\)。

    ### 步骤 4:尝试更小的 \\(x\\)
    让我们尝试更接近 14 的 \\(x\\) 值,但重点关注较小的元音字母数量。

    #### 情况 5:\\(x = 12\\)
    - \\(y = (12 - 14)^{10} = (-2)^{10} = 1024\\)。
    - 将 \\(y\\) 写作中文数字表述: "一千零二十四"。
    - 计算元音字母:共 6 个元音字母(如前所述)。
    - \\(x = 12\\),然而 \\(y\\) 中的元音字母数量是 6,因此 \\(12 \\neq 6\\)。这个答案不成立。

    ### 步骤 5:尝试找到一个固定点
    我们需要找到一个 \\(x\\),使得 \\((x - 14)^{10}\\) 中的元音字母数量等于 \\(x\\)。让我们尝试 \\(x = 2\\)(因为之前我们曾见过较小的元音字母数量)。

    #### 情况 6:\\(x = 2\\)
    - \\(y = (2 - 14)^{10} = (-12)^{10}\\)。
    - \\((-12)^{10} = 12^{10}\\)(因为 10 是偶数)。
    - \\(12^5 = 248,832\\),因此 \\(12^{10} = (12^5)^2 = 248,832^2\\)。
    - \\(248,832^2 = 61,917,364,224\\)。
    - 将 \\(y\\) 写作中文数字表述: "六十一亿九百十七万三千六百二十四"。
    - 计算元音字母:
      - i(1),o(1),e(1),i(2),i(3),o(2),e(2),e(3),i(4),o(3),o(4),u(1),a(1),o(5),e(4),o(6) → 共 16 个元音字母。
    - \\(x = 2\\),然而 \\(y\\) 中的元音字母数量是 16,因此 \\(2 \\neq 16\\)。这个答案不成立。

    ### 步骤 6:结论
    在尝试了多个 \\(x\\) 值之后,我们发现 \\(y = (x - 14)^{10}\\) 中的元音字母数量并不总是等于 \\(x\\)。问题可能没有一个解,使得结果中的元音字母数量刚好等于 \\(x\\),或者需要一个我们尚未找到的特定 \\(x\\)。

    考虑进行进一步探索或澄清(例如,\\(x\\) 的约束条件,数名约定)。

点击全屏模式,点击全屏退出

  • DeepSeek R1 的回复如下:

最终结果:果然,这两个模型都没能解决问题。❌

这个问题似乎已经被OpenAI的o1模型解决了。

总结:

说到数学题,两个模型在前两道相对简单的题上都表现得很好,但当遇到一个需要思考的难题时,两者都没能搞定 ❌。从这些结果来看,两者表现得差不多,所以很难说谁更胜一筹。

写代码

现在,让我们看看这些模型是如何处理一个棘手的LeetCode问题的,该问题仅有12.8%的接受率:找到第一个几乎相等的子串。这个问题最近才被添加,所以它们很可能没有训练过这方面的问题。

    你将得到两个字符串 s 和 pattern。

    如果可以在字符串 x 中最多改变一个字符使其与 y 完全相同,则称字符串 x 为几乎相等的 y。

    使字符串 s 中几乎相等的 pattern 的最短子字符串的最小起始索引。如果不存在这样的起始索引,则返回 -1。

    子字符串是指字符串内连续字符序列。

    示例 1:
    输入:s = "abcdefg", pattern = "bcdffg"
    输出:1

    解释:
    子串 s[1..6] == "bcdefg" 可以通过将 s[4] 改为 "f" 转变为 "bcdffg"。

    示例 2:
    输入:s = "ababbababa", pattern = "bacaba"
    输出:4

    解释:
    子串 s[4..9] == "bababa" 可以通过将 s[6] 改为 "c" 转变为 "bacaba"。

    示例 3:
    输入:s = "abcd", pattern = "dba"
    输出:-1

    示例 4:
    输入:s = "dde", pattern = "d"
    输出:0

    约束条件:
    1 <= pattern.length < s.length <= 10^5
    s 和 pattern 仅包含小写英文字母。

切换到全屏模式 退出全屏模式

  • Grok 3 是这么说的:
    class Solution:
        def 最小子索引(self, s: str, pattern: str) -> int:
            n = len(pattern)

            # 帮助函数,用于检查两个字符串是否最多差一个字符
            def 最多差一个字符(s1: str, s2: str) -> bool:
                if len(s1) != len(s2):
                    return False

                # 统计字符差异
                diff_count = 0
                for c1, c2 in zip(s1, s2):
                    if c1 != c2:
                        diff_count += 1
                    if diff_count > 1:
                        return False
                return True

            # 用长度为n的窗口在字符串s上滑动
            for i in range(len(s) - n + 1):
                # 获取当前子串
                substring = s[i:i+n]
                # 检查子串是否最多差一个字符
                if 最多差一个字符(substring, pattern):
                    return i

            return -1

点击这里切换到全屏 您可以点击这里切换回正常模式

这段代码确实完成了所要求的任务,但在某些测试集上遇到了时间限制超时。虽然它解决了这个问题,但这并不是这个问题的最佳解决方案。

  • DeepSeek R1 的回应:
    class Solution:
        def minStartingIndex(self, s: str, pattern: str) -> int:
            ans = self.find_almost_equal_substring(s, pattern)
            return ans

        def compute_z(self, s):
            n = len(s)
            Z = [0] * n
            Z[0] = 0  # 第一个字符是整个字符串,这里不考虑它
            l, r = 0, 0
            for i in range(1, n):
                if i > r:
                    l = r = i
                    while r < n and s[r - l] == s[r]:
                        r += 1
                    Z[i] = r - l
                    r -= 1
                else:
                    k = i - l
                    if Z[k] < r - i + 1:
                        Z[i] = Z[k]
                    else:
                        l = i
                        while r < n and s[r - l] == s[r]:
                            r += 1
                        Z[i] = r - l
                        r -= 1
            return Z

        def find_almost_equal_substring(self, s, pattern):
            m = len(pattern)
            n = len(s)
            if m == 0:
                return 0
            if n < m:
                return -1

            # 步骤1:检查完全匹配
            exact = s.find(pattern)
            if exact != -1:
                return exact

            # 步骤2:使用Z算法来计算lcp和lcs数组
            # 计算lcp(模式在s[i]处的最长前缀)
            concat_lcp = pattern + '#' + s
            Z_lcp = self.compute_z(concat_lcp)
            lcp = [0] * n
            for i in range(n):
                lcp[i] = Z_lcp[m + 1 + i]

            # 计算lcs(模式在s[i]处的最长后缀)
            reversed_pattern = pattern[::-1]  # 反转的模式
            reversed_s = s[::-1]  # 反转的字符串
            concat_lcs = reversed_pattern + '#' + reversed_s
            Z_lcs = self.compute_z(concat_lcs)
            lcs = [0] * n
            len_rev_pat = len(reversed_pattern)
            for i in range(n):
                pos_in_rev_s = i
                pos_in_concat = len_rev_pat + 1 + pos_in_rev_s
                if pos_in_concat >= len(Z_lcs):
                    lcs_val = 0
                else:
                    lcs_val = Z_lcs[pos_in_concat]
                lcs[n - 1 - i] = lcs_val

            min_index = float('inf')

            # 遍历模式中的每个可能的j
            for j in range(m):
                required_prefix = j
                required_suffix = m - j - 1

                # 遍历s中可能的起始索引i(从n-m+1开始)
                for i in range(n - m + 1):
                    # 检查前缀条件
                    if lcp[i] < required_prefix:
                        continue
                    # 检查后缀条件
                    suffix_start = i + j + 1
                    if suffix_start >= n:
                        continue
                    if lcs[suffix_start] < required_suffix:
                        continue
                    # 检查当前字符是否与模式中的对应字符不匹配
                    if s[i + j] != pattern[j]:
                        if i < min_index:
                            min_index = i
                            # 如果可能,提前返回
                            if min_index == 0:
                                return 0
                            # 突破内层循环,因为我们寻找最早的i作为起始索引
                            break

            return min_index if min_index != float('inf') else -1

全屏 退出全屏

这真是出乎意料,从DeepSeek R1的角度来看。代码在第一个测试案例就失败了。再说说代码质量,代码质量也很差。

嗯,非常赞同这条微博:

(点击链接查看原图)

简述

在这里,Grok 3 显然是赢家。✅它至少提供了一段可以运行的代码,虽然不是最优的。相比之下,DeepSeek R1 编写的代码连最简单的测试用例都无法通过,并且代码冗长且质量差。❌

创意写作

某一天,一个男人从旧货市场买了一台旧打字机,却发现他用这台打字机打出来的东西都会成真,但这一切却伴随着一个黑暗的转折。他用打字机给一位老朋友写了一封信,没想到不久真的收到了回信。随后,他试着写下自己的心愿,却发现心愿实现的同时,身边的人和物却随之消失。最后,他才明白,他所拥有的这种力量并非无代价的恩赐,而是需要付出沉重代价的。

  • Grok 3 的回应:

  • DeepSeek R1 的回答

总结

尽管人们说DeepSeek R1是最好的写作模型之一:

(一款AI写作工具)

在这里,我必须说两者的表现出色,仅用三个段落就巧妙地编织和完成了整个情节转折,但我更倾向于Grok 3模型的回复 ✅,而不是DeepSeek R1模型的。

这个故事感觉更顺。

……

最终裁定!

基于这些观察,这是我的最后看法:

  • Grok 3 和 DeepSeek R1 在 推理题数学 方面表现差不多。选哪个都差不多。

  • 编码方面,Grok 3 在编码方面明显优于 DeepSeek R1。DeepSeek R1 在代码质量和整体答案方面则相形见绌。

  • 这两个模型在创意写作方面都很强,但我更喜欢Grok 3的回答,感觉更吸引人,更自然和流畅,感觉更整洁。

我基本上赞同这位朋友Satoshi关于Grok 3和DeepSeek R1这两部分的比较。

你觉得呢?在下面的评论里留言告诉我你的看法吧!👇🏻

[ ](/shricodev)

Shrijal Acharya 关注他


(点击关注)

全栈软件开发工程师 • 开源贡献者 • Oppia合作开发者 • 寻求合作(详情请见 此处

0人推荐
随时随地看视频
慕课网APP