大家都知道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合作开发者 • 寻求合作（详情请见 此处）