Claude 3.7 Sonnet与Qwen 2.5 Coder：哪个编码任务能力更强？

Claude 3.7 Sonnet 和 Qwen 2.5 Coder 32B Instruct 是用于编程和代码生成的领先人工智能模型。Qwen 2.5 以其高效和清晰的编码风格脱颖而出，而 Claude 3.7 Sonnet 则在上下文理解和适应性方面大放异彩。在本文中，我将对它们生成的代码进行比较，重点关注语法质量、结构连贯性和整体性能。对它们编码优势的详细分析将帮助您选择最适合您编程需求的机型。

Claude 3.7 Sonnet和Qwen 2.5 Coder的规格

本节比较 QwenLM 和 Anthropic AI 的最新编码语言模型。

基准测试：Claude 3.7 Sonnet vs Qwen 2.5 Coder

以下是不同基准测试的结果：

Qwen 2.5 Coder

Source: Qwen

• 代码生成：Qwen2.5-Coder-32B-Instruct 在多个流行的代码生成基准测试（EvalPlus、LiveCodeBench、BigCodeBench）中取得了开源模型中的最佳性能，其性能与 GPT-4o 相比也具有竞争力。
• 代码纠正：代码纠正是一项重要的编程技能。Qwen2.5-Coder-32B-Instruct 可以帮助用户纠正代码中的错误，提高编程效率。Aider 是代码纠正的常用基准，Qwen2.5-Coder-32B-Instruct 在 Aider 上的得分为 73.7，与 GPT-4o 的表现相当。
• 代码推理：代码推理是指模型学习代码执行过程并准确预测模型输入和输出的能力。最近发布的 Qwen2.5-Coder-7B-Instruct 在代码推理方面的表现已经令人印象深刻，而这个 32B 模型则更进一步。

Claude 3.7 Sonnet

Source: Anthropic AI

• Claude 3.7 Sonnet 在 SWE-bench Verified（评估人工智能模型解决真实世界软件问题的能力）上取得了最先进的性能。有关脚手架的更多信息，请参阅附录。
• 它在 TAU-bench 上取得了一流的性能，TAU-bench 是一个测试人工智能代理在复杂现实世界任务中与用户和工具交互的框架。有关脚手架的更多信息，请参阅附录。
• 它在指令遵循、一般推理、多模态能力和代理编码等方面表现出色，在数学和科学方面的扩展思维能力也有显著提升。除了传统的基准测试外，它在我们的 Pokémon 游戏测试 中的表现甚至超过了之前的所有模型。

Claude 3.7 Sonnet与Qwen 2.5 Coder任务能力测试对比

在本节中，我将使用不同的提示来测试这两个模型的编码能力，并确定哪个模型在每个任务中表现出色。

任务 1：HTML Code

提示词：Create a single HTML file that sets up a basic Three.js scene with a rotating 3D globe. The globe should have high detail (64 segments), use a placeholder texture for the Earth’s surface, and include ambient and directional lighting for realistic shading. Implement smooth rotation animation around the Y-axis, handle window resizing to maintain proper proportions, and use antialiasing for smoother edges. Explanation: Scene Setup : Initializes the scene, camera, and renderer with antialiasing. Sphere Geometry : Creates a high-detail sphere geometry (64 segments). Texture : Loads a placeholder texture using THREE.TextureLoader. Material & Mesh : Applies the texture to the sphere material and creates a mesh for the globe. Lighting : Adds ambient and directional lights to enhance the scene’s realism. Animation : Continuously rotates the globe around its Y-axis. Resize Handling : Adjusts the renderer size and camera aspect ratio when the window is resized.

输出：

观察对比

Qwen 2.5 Coder

优点

• 在启用抗锯齿的情况下正确初始化 Three.js 场景、摄像头和渲染器。
• 使用 SphereGeometry(1, 64, 64) 创建高细节球体，满足球体细节要求。
• 使用 THREE.TextureLoader 正确加载纹理，使用的是来自 threejs.org/examples/…. 的高质量占位符。
• 实现环境光照和定向光照，以达到逼真效果。
• 通过 requestAnimationFrame() 平滑旋转地球仪。
• 通过更新摄像头长宽比和渲染器大小，能很好地处理窗口大小调整。

缺点:

• 使用硬编码的外部纹理路径，如果链接不可用，可能会中断。
• 缺乏加载指示器，导致在纹理加载前屏幕一片空白。

Claude 3.7 Sonnet

优点

• 在纹理加载过程中显示 “Loading…（正在加载…）”，增强用户体验。
• 使用 THREE.PerspectiveCamera(45, aspectRatio, 0.1, 1000) 设置场景和摄像机，视野范围比 Qwen 的 75 度设置更广。
• 使用 SphereGeometry(1, 64, 64) 制作细节丰富的球体，满足要求。
• 使用更高强度（1.0）的环境光照和定向光照，以获得更逼真的效果。
• 使用 requestAnimationFrame() 确保流畅的动画效果。
• 通过 renderer.setPixelRatio(window.devicePixelRatio)，改进了移动缩放功能，以适应高 DPI 屏幕。
• 整洁地组织代码，分离纹理加载和呈现逻辑。

缺点

• 依赖于无效的纹理路径（textureLoader.load(‘/api/placeholder/1024/512’)），除非修复，否则会导致纹理丢失。
• 将其封装在纹理加载回调中会延迟渲染，如果纹理加载失败，渲染可能会停止。
• 定义 bumpScale：定义了 0.02 的凹凸贴图，导致效果无效。

Qwen 2.5 Coder 在纹理加载功能方面提供了更可靠的基准，而 Claude 3.7 Sonnet 则将用户体验和可扩展性放在首位，但在纹理路径和凹凸贴图等实现细节方面有所欠缺。

结论

Claude 3.7 Sonnet ❌ | Qwen 2.5 Coder ✅

任务 2：数据可视化

提示词：Write a Python program that visualizes the sorting process of an array using Matplotlib. Implement the Merge Sort algorithm and display the array as a bar chart after each merge operation. The bars should dynamically update to show progress.

输出：

观察对比

Qwen 2.5 Coder

优点

• 简洁明了：采用简约方法，增强代码的可读性和可理解性。
• 基于生成器的排序：利用收益率有效返回中间排序状态。
• 使用 FuncAnimation：采用 Matplotlib 的动画框架，实现流畅有效的可视化。
• 最小化依赖性：只需要 NumPy 和 Matplotlib，确保了设置和执行的简便性。

缺点

• 动画实现不正确：更新函数预期会出现条形图，但却无法在可视化中正确更新条形图的高度。
• 初始化缺失（init 函数问题）：初始化函数在条形图正确定义之前就引用了它们。
• 视觉反馈有限：缺乏颜色变化或标签来突出显示排序步骤，从而降低了清晰度。
• 固定的排序速度：无法调整动画速度的延迟，限制了用户的控制。

Claude 3.7 Sonnet

优点

• 增强可视化：使用彩色条（皇家蓝、橙色和红色）突出显示活动排序区域，提高视觉清晰度。
• 实时状态更新：动态显示排序步骤信息，提供更好的用户反馈。
• 可调速度 ：允许通过延迟（time.sleep(self.speed)）对排序速度进行微调，从而提供用户控制。
• 互动性更强，信息量更大：包括一个合并操作计数器和跟踪进度的文本更新，增强了互动性。

缺点

• 代码更复杂：包含更多行代码，初学者较难掌握。
• 阻塞执行：依赖 time.sleep()，在某些环境下可能会破坏流畅的动画效果。
• 严重影响性能：频繁更新整个图形，可能会导致大型数据集的延迟。

结论

Claude 3.7 Sonnet ✅ | Qwen 2.5 Coder ❌

任务 3：最大子数组

提示词：Design and implement an efficient algorithm to solve the  “Maximum Subarray Sum” problem, commonly known as Kadane’s Algorithm. Given an array of integers, your task is to find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Qwen 2.5 Coder 32B

def max_subarray_sum(arr):
if not arr:
raise ValueError("Array must contain at least one number")
# Initialize variables
maxSoFar = arr[0]
maxEndingHere = arr[0]
# Iterate through the array starting from the second element
for i in range(1, len(arr)):
# Update maxEndingHere
maxEndingHere = max(arr[i], maxEndingHere + arr[i])
# Update maxSoFar if needed
maxSoFar = max(maxSoFar, maxEndingHere)
return maxSoFar
# Example usage
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print("Maximum subarray sum is:", max_subarray_sum(arr))

输出：

Maximum subarray sum is: 6

Claude 3.7 Sonnet

function maxSubArray(nums) {
// Handle edge case of empty array
if (nums.length === 0) return 0;
let maxSum = nums[0];     // Best solution found so far
let currentSum = nums[0]; // Best solution ending at current position
for (let i = 1; i < nums.length; i++) {
currentSum = Math.max(nums[i], currentSum + nums[i]);
maxSum = Math.max(maxSum, currentSum);
}
return maxSum;
}
// Example usage
function testKadane() {
const testCases = [
{ input: [-2, 1, -3, 4, -1, 2, 1, -5, 4], expected: 6 },  // Subarray [4, -1, 2, 1]
{ input: [1], expected: 1 },                              // Single element
{ input: [-1], expected: -1 },                            // Single negative element
{ input: [-2, -3, -1, -5], expected: -1 },                // All negative elements
{ input: [5, 4, -1, 7, 8], expected: 23 }                 // Subarray [5, 4, -1, 7, 8] (entire array)
];
for (const test of testCases) {
const result = maxSubArray(test.input);
console.log(`Input: [${test.input}]`);
console.log(`Expected: ${test.expected}, Result: ${result}`);
console.log(`Test ${result === test.expected ? 'PASSED' : 'FAILED'}`);
console.log('---');
}
}
testKadane();

输出：

Input: [-2,1,-3,4,-1,2,1,-5,4]Expected: 6, Result: 6Test PASSED---Input: [1]Expected: 1, Result: 1Test PASSED---Input: [-1]Expected: -1, Result: -1Test PASSED---Input: [-2,-3,-1,-5]Expected: -1, Result: -1Test PASSED---Input: [5,4,-1,7,8]Expected: 23, Result: 23Test PASSED---

观察对比

Qwen 2.5 Coder 32B

优点

• 简洁明了：采用逻辑清晰的简约方法。
• 高效（复杂度为 O(n)）：以最佳方式执行 Kadane 算法。
• 处理空数组：如果数组为空，会引发错误，防止出现未定义的行为。

缺点

• 缺乏边缘案例测试：没有内置测试用例来验证各种情况。
• 没有详细解释：不提供帮助初学者理解逻辑的内联注释。
• 不返回子数组：只返回最大和，不返回产生最大和的子数组。

Claude 3.7 Sonnet

优点

• 代码注释详细：每一步都有详细解释。
• 包含测试用例：包含多个测试用例，可验证不同场景下的正确性。
• 优雅地处理边缘情况：测试空数组、单元素数组和全负数。
• 高效（O(n) 复杂度）：采用与 Qwen 实现相同的最优方法。

缺点

• 只返回最大和：与 Qwen 的版本一样，它不返回实际的子数组。
• 不处理空数组错误：返回 0 而不是抛出错误。

结论

Claude 3.7 Sonnet ✅ | Qwen 2.5 Coder ❌

任务 4：迷宫解法

提示词：Use an SQLite database to generate and solve a simple 5×5 ASCII maze.The maze should be stored in a table Maze(x, y, type) where type is ‘wall’ or ‘path’. Implement a SQL query to find the shortest path from (0,0) to (4,4) using recursive Common Table Expressions (CTEs).

import sqlite3
# Connect to SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('maze.db')
cursor = conn.cursor()
# Create the Maze table
cursor.execute('''
CREATE TABLE IF NOT EXISTS Maze (
x INTEGER,
y INTEGER,
type TEXT,
PRIMARY KEY (x, y)
)
''')
# Insert the sample maze into the table
maze_data = [
(0, 0, 'path'), (0, 1, 'path'), (0, 2, 'path'), (0, 3, 'path'), (0, 4, 'path'),
(1, 0, 'path'), (1, 1, 'path'), (1, 2, 'path'), (1, 3, 'wall'), (1, 4, 'path'),
(2, 0, 'path'), (2, 1, 'wall'), (2, 2, 'path'), (2, 3, 'wall'), (2, 4, 'path'),
(3, 0, 'path'), (3, 1, 'path'), (3, 2, 'path'), (3, 3, 'wall'), (3, 4, 'path'),
(4, 0, 'path'), (4, 1, 'path'), (4, 2, 'path'), (4, 3, 'path'), (4, 4, 'path'),
(1, 2, 'path'), (2, 2, 'path'), (3, 2, 'path')  # Ensure paths are correctly set
]
# Insert the maze data
cursor.executemany('INSERT INTO Maze (x, y, type) VALUES (?, ?, ?)', maze_data)
conn.commit()
# Define the recursive CTE query to find the shortest path
query = '''
WITH RECURSIVE Path AS (
-- Anchor member: Start at (0, 0)
SELECT x, y, type, CAST(CAST(x AS TEXT) || ',' || CAST(y AS TEXT) AS TEXT) AS path, 0 AS cost
FROM Maze
WHERE x = 0 AND y = 0
UNION ALL
-- Recursive member: Explore neighbors
SELECT m.x, m.y, m.type, p.path || ',' || CAST(m.x AS TEXT) || ',' || CAST(m.y AS TEXT) AS path, p.cost + 1 AS cost
FROM Maze m
JOIN Path p ON (m.x = p.x + 1 AND m.y = p.y) OR
(m.x = p.x - 1 AND m.y = p.y) OR
(m.x = p.x AND m.y = p.y + 1) OR
(m.x = p.x AND m.y = p.y - 1)
WHERE m.type = 'path' AND
m.x BETWEEN 0 AND 4 AND
m.y BETWEEN 0 AND 4 AND
CAST(m.x AS TEXT) || ',' || CAST(m.y AS TEXT) NOT IN (SELECT SUBSTR(path, -4) FROM Path)
)
-- Select the shortest path to (4, 4)
SELECT path, cost
FROM Path
WHERE x = 4 AND y = 4
ORDER BY cost ASC
LIMIT 1
'''
# Execute the query
cursor.execute(query)
result = cursor.fetchone()
if result:
path, cost = result
print(f"Shortest path: {path}")
print(f"Cost: {cost}")
else:
print("No path found")
# Close the connection
conn.close()

输出：

---------------------------------------------------------------------------
IntegrityError                            Traceback (most recent call last)
<ipython-input-7-69b873cc8b5b> in <cell line: 28>()
26 
27 # Insert the maze data
---> 28 cursor.executemany('INSERT INTO Maze (x, y, type) VALUES (?, ?, ?)', maze_data)
29 conn.commit()
30 
IntegrityError: UNIQUE constraint failed: Maze.x, Maze.y

Claude 3.7 Sonnet

import sqlite3
import random
def create_database():
"""Create and initialize the SQLite database for the maze."""
conn = sqlite3.connect(':memory:')  # Using in-memory database for simplicity
cursor = conn.cursor()
# Create the maze table
cursor.execute('''
CREATE TABLE Maze (
x INTEGER,
y INTEGER,
type TEXT,
PRIMARY KEY (x, y)
)
''')
# Generate a random maze
generate_maze(cursor)
return conn, cursor
def generate_maze(cursor):
"""Generate a random 5x5 maze and store it in the database."""
# First, fill everything with walls
for x in range(5):
for y in range(5):
cursor.execute('INSERT INTO Maze VALUES (?, ?, ?)', (x, y, 'wall'))
# Create a simple maze with a guaranteed path from start to end
# Using a simplified version of randomized DFS for maze generation
visited = set()
stack = [(0, 0)]
visited.add((0, 0))
# Set start and end as paths
cursor.execute('UPDATE Maze SET type = ? WHERE x = ? AND y = ?', ('path', 0, 0))
cursor.execute('UPDATE Maze SET type = ? WHERE x = ? AND y = ?', ('path', 4, 4))
while stack:
x, y = stack[-1]
# Get unvisited neighbors
neighbors = []
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < 5 and 0 <= ny < 5 and (nx, ny) not in visited:
neighbors.append((nx, ny))
if neighbors:
# Choose a random unvisited neighbor
nx, ny = random.choice(neighbors)
visited.add((nx, ny))
stack.append((nx, ny))
# Mark as path
cursor.execute('UPDATE Maze SET type = ? WHERE x = ? AND y = ?', ('path', nx, ny))
else:
# Backtrack
stack.pop()
# Make sure there's a valid path from start to end
# This is a simplified approach and might create a very direct path
make_valid_path(cursor)
def make_valid_path(cursor):
"""Ensure there's a valid path from (0,0) to (4,4)."""
# Simple approach: create a direct path if needed
for i in range(5):
cursor.execute('UPDATE Maze SET type = ? WHERE x = ? AND y = ?', ('path', i, i))
def print_maze(cursor):
"""Print the maze in ASCII format."""
cursor.execute('SELECT x, y, type FROM Maze ORDER BY y, x')
rows = cursor.fetchall()
maze_grid = [['#' for _ in range(5)] for _ in range(5)]
for x, y, cell_type in rows:
maze_grid[y][x] = '#' if cell_type == 'wall' else ' '
print("Maze:")
for row in maze_grid:
print(''.join(row))
def print_solution_path(cursor, path):
"""Print the maze with the solution path marked."""
cursor.execute('SELECT x, y, type FROM Maze ORDER BY y, x')
rows = cursor.fetchall()
# Create maze grid
maze_grid = [['#' for _ in range(5)] for _ in range(5)]
for x, y, cell_type in rows:
maze_grid[y][x] = '#' if cell_type == 'wall' else ' '
# Mark path
for x, y in path:
maze_grid[y][x] = 'X'
# Mark start and end
maze_grid[0][0] = 'S'
maze_grid[4][4] = 'E'
print("\nSolution Path:")
for row in maze_grid:
print(''.join(row))
def solve_maze_with_sql(cursor):
"""Solve the maze using recursive Common Table Expressions (CTE) in SQL."""
query = '''
WITH RECURSIVE
-- Define starting point
PathFinder(x, y, path, visited) AS (
SELECT 0, 0, '(0,0)', '(0,0)'
UNION ALL
-- Recursive part: explore in four directions
SELECT 
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.x + 1
WHEN m.type = 'path' AND direction = 1 THEN p.x
WHEN m.type = 'path' AND direction = 2 THEN p.x - 1
WHEN m.type = 'path' AND direction = 3 THEN p.x
ELSE p.x
END,
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.y
WHEN m.type = 'path' AND direction = 1 THEN p.y + 1
WHEN m.type = 'path' AND direction = 2 THEN p.y
WHEN m.type = 'path' AND direction = 3 THEN p.y - 1
ELSE p.y
END,
p.path || '->' || '(' || 
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.x + 1
WHEN m.type = 'path' AND direction = 1 THEN p.x
WHEN m.type = 'path' AND direction = 2 THEN p.x - 1
WHEN m.type = 'path' AND direction = 3 THEN p.x
ELSE p.x
END || ',' || 
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.y
WHEN m.type = 'path' AND direction = 1 THEN p.y + 1
WHEN m.type = 'path' AND direction = 2 THEN p.y
WHEN m.type = 'path' AND direction = 3 THEN p.y - 1
ELSE p.y
END || ')',
p.visited || ',' || '(' || 
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.x + 1
WHEN m.type = 'path' AND direction = 1 THEN p.x
WHEN m.type = 'path' AND direction = 2 THEN p.x - 1
WHEN m.type = 'path' AND direction = 3 THEN p.x
ELSE p.x
END || ',' || 
CASE
WHEN m.type = 'path' AND direction = 0 THEN p.y
WHEN m.type = 'path' AND direction = 1 THEN p.y + 1
WHEN m.type = 'path' AND direction = 2 THEN p.y
WHEN m.type = 'path' AND direction = 3 THEN p.y - 1
ELSE p.y
END || ')'
FROM 
PathFinder p,
(SELECT 0 AS direction UNION ALL SELECT 1 UNION ALL SELECT 2 UNION ALL SELECT 3) AS dirs,
Maze m
WHERE 
-- Check direction:
-- 0: right, 1: down, 2: left, 3: up
(
(dirs.direction = 0 AND m.x = p.x + 1 AND m.y = p.y) OR
(dirs.direction = 1 AND m.x = p.x AND m.y = p.y + 1) OR
(dirs.direction = 2 AND m.x = p.x - 1 AND m.y = p.y) OR
(dirs.direction = 3 AND m.x = p.x AND m.y = p.y - 1)
)
-- Check if the new position is a valid path and hasn't been visited
AND m.type = 'path'
AND p.visited NOT LIKE '%(' || m.x || ',' || m.y || ')%'
)
-- Select the shortest path to the destination
SELECT path
FROM PathFinder
WHERE x = 4 AND y = 4
ORDER BY length(path)
LIMIT 1;
'''
cursor.execute(query)
result = cursor.fetchone()
if result is None:
print("No solution found!")
return None
# Parse the path string into coordinates
path_str = result[0]
coord_strs = path_str.split('->')
path = []
for coord_str in coord_strs:
# Extract x and y from strings like "(0,0)"
coord = coord_str.strip('()').split(',')
path.append((int(coord[0]), int(coord[1])))
return path
def main():
conn, cursor = create_database()
# Print the generated maze
print_maze(cursor)
# Solve the maze
print("\nSolving maze with SQL recursive CTE...")
path = solve_maze_with_sql(cursor)
if path:
print(f"Solution found! Path length: {len(path)}")
print(f"Path: {path}")
# Visualize the solution
print_solution_path(cursor, path)
conn.close()
if __name__ == "__main__":
main()

输出：

Maze:
Solving maze with SQL recursive CTE...
Solution found! Path length: 9
Path: [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (4, 1), (4, 2), (4, 3), 
(4, 4)]
Solution Path:
SXXXX
X
X
X
E

观察对比

Qwen 2.5 Coder 32B

优点

• 简洁直接：使用结构化递归 CTE 查找最短路径。
• 优化查询：SQL 可高效计算最短路径，无需手动回溯。
• 数据库持久性：将迷宫存储在数据库中，方便日后执行查询。

缺点

• 静态迷宫数据：预设迷宫并手动插入，缺乏随机性。
• 无视觉表现：不打印迷宫或以图形方式显示解决方案。
• 有限的错误处理：无法验证迷宫是否包含有效的起点到终点路径。

Claude 3.7 Sonnet

优点

• 动态迷宫生成：使用基于 DFS 的随机算法创建独一无二的迷宫。
• 可视化表示：使用 ASCII 码打印迷宫并突出显示解谜路径。
• 内存数据库：使用 SQLite 的内存模式，使执行速度更快，并避免文件处理开销。
• 确保有效路径：保证从起点到终点的连接，防止出现不可能的迷宫。

缺点

• 更复杂：有额外的迷宫生成逻辑，代码更长。
• 寻路效率可能较低：SQL 寻路器并不总是返回最优路径。
• 冗长的 SQL 查询：递归 CTE 解决方案比 Qwen 的更复杂。

结论

Claude 3.7 Sonnet ✅ | Qwen 2.5 Coder ❌

最终结论

Qwen 2.5 Coder 32B 和 Claude 3.7 Sonnet 在编码领域都具有独特的优势。Claude 3.7 Sonnet 在各种基准测试中表现出卓越的性能，尤其是在推理和代码生成任务方面。不过，Qwen 2.5 Coder 32B 凭借高效的数学问题解决能力，也占据了一席之地。根据您的具体需求，无论是广泛的上下文处理还是更快的输出速度，这两种模式都可以成为开发人员和程序员的宝贵工具。