大家都知道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 是来自 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是最好的写作模型之一:
在这里,我必须说两者的表现出色,仅用三个段落就巧妙地编织和完成了整个情节转折,但我更倾向于Grok 3模型的回复 ✅,而不是DeepSeek R1模型的。
这个故事感觉更顺。
……
最终裁定!基于这些观察,这是我的最后看法:
-
Grok 3 和 DeepSeek R1 在 推理题 和 数学 方面表现差不多。选哪个都差不多。
-
在编码方面,Grok 3 在编码方面明显优于 DeepSeek R1。DeepSeek R1 在代码质量和整体答案方面则相形见绌。
- 这两个模型在创意写作方面都很强,但我更喜欢Grok 3的回答,感觉更吸引人,更自然和流畅,感觉更整洁。
我基本上赞同这位朋友Satoshi关于Grok 3和DeepSeek R1这两部分的比较。
你觉得呢?在下面的评论里留言告诉我你的看法吧!👇🏻
[
(点击关注)
全栈软件开发工程师 • 开源贡献者 • Oppia合作开发者 • 寻求合作(详情请见 此处)