Qwen Max
変動分析 · 2026年 第12週
Qwen Max 2026年 第12週 コード実行次元が 38.6 点上昇。主にDebug：链表反转、全排列（去重 + 有序）で得点
スコア比較
42.2
56.3
+14.1
| 次元 | 前回 | 今回 | 変動 |
|---|---|---|---|
| コード実行 | 20.2 | 58.8 | +38.6 |
| 知識総合 | 34.4 | 40.8 | +6.4 |
| 引用検証 | 60.2 | 80.6 | +20.4 |
| コストパフォーマンス | 27.9 | 42.2 | +14.3 |
| 安定性 | 53 | 30.2 | -22.8 |
| 可用性 | 100 | 100 | 0 |
失点 Top 5
供应商加权评分
33.3
0
-33.3
知識総合
calc_with_tolerance
STRICT
詳細証拠を展開
前回の回答
首先，根据给定的权重和评分计算每家供应商的加权总分。
- 准确率权重：40% 或 0.4
- 稳定性权重：25% 或 0.25
- 成本权重：20% 或 0.2
- 接入难度权重：15% 或 0.15
### A公司的加权总分
\[= 9*0.4 + 7*0.25 + 5*0.2 + 8*0.15 = 3.6 + 1.75 + 1 + 1.2 = 7.55\]
### B公司的加权总分
\[= 8*0.4 + 9*0.25 + 7*0.2 + 6*0.15 = 3.2 + 2.25 + 1.4 + 0.9 = 7.75\]
### C公司的加权总分
\[= 7*0.4 + 8*0.25 + 9*0.2 + 7*0.15 = 2.8 + 2 + 1.8 + 1.05 = 7.65\]
基于以上计算，初步排序为：
1. B公司 (7.75)
2. C公司 (7.65)
3. A公司 (7.55)
如果“稳定性”权重提升到35%，则新的权重分配如下：
- 准确率：40% 或 0.4
- 稳定性：35% 或 0.35
- 成本：20% 或 0.2
- 接入难度：5% 或 0.05
重新计算：
### A公司的新加权总分
\[= 9*0.4 + 7*0.35 + 5*0.2 + 8*0.05 = 3.6 + 2.45 + 1 + 0.4 = 7.45\]
### B公司的新加权总分
\[= 8*0.4 + 9*0.35 + 7*0.2 + 6*0.05 = 3.2 + 3.15 + 1.4 + 0.3 = 7.95\]
### C公司的新加权总分
\[= 7*0.4 + 8*0.35 + 9*0.2 + 7*0.05 = 2.8 + 2.8 + 1.8 + 0.35 = 7.75\]
调整后的新排序为：
1. B公司 (7.95)
2. C公司 (7.75)
3...
今回の回答
根据给定的权重和评分，首先计算每家供应商在初始条件下的加权总分。
- 准确率：40%
- 稳定性：25%
- 成本：20%
- 接入难度：15%
### A 供应商
- 准确率：9 * 0.4 = 3.6
- 稳定性：7 * 0.25 = 1.75
- 成本：5 * 0.2 = 1
- 接入难度：8 * 0.15 = 1.2
- **总分**：3.6 + 1.75 + 1 + 1.2 = 7.55
### B 供应商
- 准确率：8 * 0.4 = 3.2
- 稳定性：9 * 0.25 = 2.25
- 成本：7 * 0.2 = 1.4
- 接入难度：6 * 0.15 = 0.9
- **总分**：3.2 + 2.25 + 1.4 + 0.9 = 7.75
### C 供应商
- 准确率：7 * 0.4 = 2.8
- 稳定性：8 * 0.25 = 2
- 成本：9 * 0.2 = 1.8
- 接入难度：7 * 0.15 = 1.05
- **总分**：2.8 + 2 + 1.8 + 1.05 = 7.65
按照初始权重排序：
1. B (7.75)
2. C (7.65)
3. A (7.55)
当“稳定性”的权重提升到 35% 时，重新分配权重如下：
- 准确率：40%
- 稳定性：35%
- 成本：20%
- 接入难度：5%
### A 供应商（新权重）
- 准确率：9 * 0.4 = 3.6
- 稳定性：7 * 0.35 = 2.45
- 成本：5 * 0.2 = 1
- 接入难度：8 * 0.05 = 0.4
- **总分**：3.6 + 2.45 + 1 + 0.4 = 7.45
### B 供应商（新权重）
- 准确率：8 * 0.4 = 3.2
- 稳定性：9 * 0.35 = 3.15
- 成本：7 * 0.2 = 1.4
- 接入难度：6...
贪心：活动选择（返回方案）
20
0
-20
コード実行
python_unit_test
STRICT
詳細証拠を展開
前回の回答
```python
def max_activities(activities):
activities.sort(key=lambda x: (x[1], x[0]))
selected = [activities[0]]
for i in range(1, len(activities)):
if activities[i][0] >= selected[-1][1]:
selected.append(activities[i])
return selected
```
今回の回答
```python
def max_activities(activities):
activities.sort(key=lambda x: (x[1], x[0]))
selected = [activities[0]]
for i in range(1, len(activities)):
if activities[i][0] >= selected[-1][1]:
selected.append(activities[i])
return selected
```
正则表达式编写
20
0
-20
コード実行
python_unit_test
詳細証拠を展開
前回の回答
```python
pattern1 = r'^(?:\+?86|0086)?1\d{10}$'
pattern2 = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
pattern3 = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
```
今回の回答
```python
pattern1 = r'^(?:\+86|0086)?1\d{10}$'
pattern2 = r'^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$'
pattern3 = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
```
浮点精度陷阱
10
0
-10
コード実行
exact_lines
STRICT
詳細証拠を展開
前回の回答
False
True
True
今回の回答
False
True
True
代码输出：闭包
10
0
-10
コード実行
exact_lines
STRICT
詳細証拠を展開
前回の回答
[2, 2, 2]
今回の回答
[2, 2, 2]
得点 Top 5
Debug：链表反转
10
100
+90
コード実行
diff_patch_unit_test
STRICT
詳細証拠を展開
前回の回答
修正后的代码如下：
```python
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reverse_list(head):
prev = None
curr = head
while curr:
temp = curr.next # 保存当前节点的下一个节点
curr.next = prev # 反转链表
prev = curr # 移动prev和curr指针
curr = temp
return prev
```
原因：在原始代码中，`curr = curr.next`这行代码执行后，`curr`已经指向了新的下一个节点，而这个节点已经被反转连接到了`prev`上。因此，在下一次循环开始时，链表中的一部分节点就会丢失。通过引入临时变量`temp`来存储`curr`的下一个节点，可以避免这个问题。
今回の回答
修正后的完整代码如下：
```python
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def reverse_list(head):
prev = None
curr = head
while curr:
temp = curr.next # 保存当前节点的下一个节点
curr.next = prev # 将当前节点指向前一个节点
prev = curr # 更新前一个节点为当前节点
curr = temp # 更新当前节点为其下一个节点
return prev
# 辅助函数，用于创建链表
def create_linked_list(arr):
if not arr:
return None
head = ListNode(arr[0])
current = head
for value in arr[1:]:
current.next = ListNode(value)
current = current.next
return head
# 辅助函数，用于打印链表
def print_linked_list(head):
elements = []
while head:
elements.append(str(head.val))
head = head.next
print(" -> ".join(elements))
...
全排列（去重 + 有序）
10
95
+85
コード実行
python_unit_test
STRICT
詳細証拠を展開
前回の回答
```python
from itertools import permutations
def permute_unique(nums):
return [list(p) for p in sorted(set(permutations(nums)))]
```
今回の回答
```python
from itertools import permutations
def permute_unique(nums):
if not nums:
return [[]]
return [list(p) for p in sorted(set(permutations(nums)))]
```
数据流中位数
10
95
+85
コード実行
python_unit_test
STRICT
詳細証拠を展開
前回の回答
```python
import heapq
class MedianFinder:
def __init__(self):
self.small = [] # 最大堆，存储较小的一半
self.large = [] # 最小堆，存储较大的一半
def add_num(self, num: int) -> None:
if len(self.small) == len(self.large):
heapq.heappush(self.large, -heapq.heappushpop(self.small, -num))
else:
heapq.heappush(self.small, -heapq.heappushpop(self.large, num))
def find_median(self) -> float:
if len(self.small) < len(self.large):
return self.large[0]
return (-self.small[0] + self.large[0]) / 2.0
```
今回の回答
```python
import heapq
class MedianFinder:
def __init__(self):
self.small, self.large = [], []
def add_num(self, num: int) -> None:
if len(self.small) == len(self.large):
heapq.heappush(self.small, -heapq.heappushpop(self.large, num))
else:
heapq.heappush(self.large, -heapq.heappushpop(self.small, -num))
def find_median(self) -> float:
if len(self.small) > len(self.large):
return -self.small[0]
return (-self.small[0] + self.large[0]) / 2
```
Debug：DFS 环检测
10
95
+85
コード実行
diff_patch_unit_test
STRICT
詳細証拠を展開
前回の回答
```python
def has_cycle(graph):
visited = set() # 已完全访问节点
on_stack = set() # 当前递归栈中的节点
def dfs(node):
if node in on_stack:
return True
if node in visited:
return False
on_stack.add(node)
for nei in graph.get(node, []):
if dfs(nei):
return True
on_stack.remove(node)
visited.add(node)
return False
for n in graph:
if n not in visited and dfs(n):
return True
return False
```
今回の回答
```python
def has_cycle(graph):
visited = set()
recursion_stack = set()
def dfs(node):
if node in recursion_stack:
return True
if node in visited:
return False
recursion_stack.add(node)
visited.add(node)
for nei in graph.get(node, []):
if dfs(nei):
return True
recursion_stack.remove(node)
return False
for n in graph:
if n not in visited:
if dfs(n):
return True
return False
```
位运算：判断2的幂与 bit count
20
100
+80
コード実行
python_unit_test
STRICT
詳細証拠を展開
前回の回答
```python
def is_power_of_2(n):
return n > 0 and (n & (n - 1)) == 0
def count_bits(n):
count = 0
while n:
count += n & 1
n >>= 1
return count
print(is_power_of_2(0))
print(is_power_of_2(8))
print(is_power_of_2(12))
print(count_bits(15))
```
实际输出：
```
False
True
False
4
```
今回の回答
```python
def is_power_of_2(n):
return n > 0 and (n & (n - 1)) == 0
def count_bits(n):
count = 0
while n:
count += n & 1
n >>= 1
return count
print(is_power_of_2(0))
print(is_power_of_2(8))
print(is_power_of_2(12))
print(count_bits(15))
```
实际输出：
```
False
True
False
4
```