o3 vs o4-mini vs Gemini 2.5 pro:哪個模型的推理能力更強大?

o3 vs o4-mini vs Gemini 2.5 pro:哪個模型的推理能力更強大?

人工智慧模型越來越聰明,但哪一個能真正在壓力下解決問題?在本文中,我們讓 o3、o4-mini 和 Gemini 2.5 Pro 接受了一系列激烈的挑戰:物理難題、數學問題、編碼任務和真實世界的智商測試。沒有手把手教,沒有輕鬆取勝,只有對思維能力的原始測試。我們將分析每款模型在不同領域的高階推理中的表現。無論您是在追蹤人工智慧的最新發展,還是隻想知道誰能勝出,本文都能為您一一解答。

什麼是o3和o4-mini?

o3 和 o4-mini 是 OpenAI 最新的推理模型,是 o1 和 o3-mini 的後繼者,它們透過執行更深、更長的內部“思維鏈”,超越了模式匹配。它們可以代理呼叫全套 ChatGPT 工具,擅長 STEM、編碼和邏輯演繹。

  • o3:旗艦模型,計算能力約為 o1 的 10 倍,能夠“用影像思考”,進行直接的視覺推理;是深度分析任務的理想選擇。
  • o4-mini:緊湊、高效的對應模型,最佳化了速度和吞吐量;以更低的成本提供強大的數學、編碼和視覺效能。

ChatGPT

您既可以在 ChatGPT 中訪問,也可以透過響應 API 訪問。

o3和o4-mini的主要功能

以下是這些先進而強大的推理模型的一些主要特點:

  • 代理行為:它們具有主動解決問題的能力,能自主確定複雜任務的最佳方法,並高效執行多步驟解決方案。
  • 先進的工具整合:這些模型可無縫利用網路瀏覽、程式碼執行和影像生成等工具來增強其響應能力,並有效地處理複雜的查詢。
  • 多模態推理:他們可以處理視覺資訊並將其直接整合到推理鏈中,從而能夠在解釋和分析文字資料的同時解釋和分析影像。
  • 高階視覺推理(“影像思維”):這些模型可以解讀複雜的視覺輸入,如圖表、白板草圖,甚至是模糊或低質量的照片。作為推理過程的一部分,它們甚至可以處理這些影像(縮放、裁剪、旋轉、增強),以提取相關資訊。

什麼是Gemini 2.5 Pro?

Gemini 2.5 Pro 是谷歌 DeepMind 的最新人工智慧模型,旨在提供比前代更高的效能、效率和功能。它是 Gemini 2.5 系列的一部分,代表專業級版本,為開發人員和企業在功能和成本效益之間取得了平衡。

Gemini 2.5 Pro

Gemini 2.5 Pro的主要功能

Gemini 2.5 Pro 引入了多項顯著增強功能。

  • 多模式功能:該模型支援多種資料型別,包括文字、影像、影片、音訊和程式碼庫。因此,它可以處理各種輸入和輸出,成為不同領域的通用工具。
  • 先進的推理系統:Gemini 2.5 Pro 的核心是其先進的推理系統,它能讓人工智慧在有條不紊地生成響應之前對資訊進行分析。這種經過深思熟慮的方法可實現更準確、更貼近上下文的輸出。
  • 擴充套件的上下文視窗:它具有一個擴充套件的上下文視窗,可容納 100 萬個標記。這使它能夠同時處理和理解更大量的資訊。
  • 增強的編碼效能:該模型在編碼任務方面有顯著改進,可為開發人員提供更高效、更準確的程式碼生成和幫助。
  • 擴充套件的知識庫:與大多數其他模型相比,該模型使用了更多最新資料進行訓練,知識截止日期為 2025 年 1 月。

您可以透過 Google AI Studio 或 Gemini 網站(針對 Gemini Advanced 訂閱者)訪問 Gemini 2.5 Pro。

o3 vs o4-mini vs Gemini 2.5:任務對比對決

為了看看哪種模型能在現實世界的各種挑戰中脫穎而出,我們讓 o3、o4-mini 和 Gemini 2.5 在五項截然不同的任務中正面交鋒:

  • 共振衰減推理:計算色散氣體介質的吸收係數、相位速度排序和共振折射率。
  • 數列之謎:破解微妙增長序列,找出缺失項。
  • LRU 快取實現:在程式碼中設計高效能、恆定時間的最近最少使用快取。
  • 響應式作品集網頁:使用語義 HTML 和自定義 CSS 建立一個簡潔、移動友好的個人網站。
  • 多模式任務分解:分析每種模式如何應對基於影像的挑戰。

每個測試都會在深度物理推理、模式識別、編碼能力、設計流暢性和影像上下文理解等方面測試不同的優勢;因此您可以清楚地看到每個模型的優勢或不足。

任務 1:物理推理

輸入提示詞:Dispersive Gaseous Medium. A dilute gaseous medium is found to exhibit a single optical resonance at frequency \\( \omega_0 = 2\pi \cdot 10^{15} \\) Hz. The electric field of a plane wave at frequency \\( \omega_0 \\) propagating through this medium is attenuated by a factor of two over a distance of 10 meters. The frequency width of the absorption resonance is \\( \Delta \omega \\). (a) What is the absorption coefficient \\( \alpha \\) at resonance? (b) Arrange in ascending order the propagation velocities at frequencies \\( \omega_0, \omega_0 + \Delta \omega / 10 \\), and \\( \omega_0 – \Delta \omega / 10 \\). Show your reasoning. (c) If there were no other resonances in the medium, what are the approximate numerical values of the index of refraction and the propagation velocity on resonance?

o3 輸出:

o3物理推理任務-01 o3物理推理任務-02 o3物理推理任務-03

o4-mini 輸出:

o4-mini物理推理任務-01 o4-mini物理推理任務-02 o4-mini物理推理任務-03

Gemini 2.5 輸出:

Gemini 2.5物理推理任務-01 Gemini 2.5物理推理任務-02 Gemini 2.5物理推理任務-03 Gemini 2.5物理推理任務-04 Gemini 2.5物理推理任務-05

輸出結果對比

標準 O3 O4-mini Gemini 2.5
吸收係數計算 推導正確;使用了場衰減方程和比爾-朗伯定律 正確、簡明;清楚地使用 κ 並與α 聯絡起來 正確、詳細;使用對數變換幷包含單位
相位速度排序 正確,數學清晰,物理解釋正確 正確,邏輯推理清晰 正確,概念性強,推理直觀
共振頻率和速度 精確的數值,包括單位換算和含義 近似但清晰;假定背景指數≈1 定性解釋;定量略少
解釋的清晰度和深度 深入但技術性強 簡明扼要,便於學生理解 概念豐富,結構合理;可讀性強

最終結論

所有三種模式都能提供正確、連貫的答案,但 Gemini 2.5 的整體表現最為突出。O3 在技術上最為嚴謹,而 O4-mini 則在速度和清晰度方面表現出色。Gemini 2.5 在深度、概念清晰度和結構化表達之間取得了最佳平衡。它不僅能提供正確的結果,還能以直觀的推理解釋基本的物理原理,是理解和驗證的理想選擇。

任務 2:數字推理

輸入提示:Select the number from among the given options that can replace the question mark (?) in the following series: 16, 33, 100, 401,?

  • 1235
  • 804
  • 1588
  • 2006

o3 輸出:

o3數字推理

o4-mini 輸出:

o4-mini數字推理

Gemini 2.5 輸出:

Gemini 2.5數字推理

輸出結果對比

標準 O3 O4-mini Gemini 2.5
正確性 正確答案(2006) 正確答案(2006) 正確答案(2006)
模式識別
明確指出乘數遞增 +1 簡潔地識別遞迴公式 逐步引導邏輯
解釋風格 略有技術性,但整潔 簡潔明瞭 最詳細、最直觀
學生清晰度 適合中級學習者 便於快速理解 適合所有水平

最終結論:

所有三個模型都能正確識別圖案並得出正確答案,即 2006 年。Gemini 2.5 提供了詳細的分步解釋,而 O3 則清楚地解釋了邏輯,但 O4-mini 則以其優雅和數學精確性脫穎而出。O4-mini 將序列表達為一個一般公式:an=an-1×n+1a_n = a_{n-1} \times n + 1an=an-1×n+1,以最簡潔、最有條理的方式捕捉到了基本模式。因此,它非常適合那些喜歡清晰和緊湊推理的學習者。O4-mini 提供了最佳的整體解釋。

任務 3:編碼任務

輸入提示詞:Design and implement a data structure for Least Recently Used (LRU) cache. Implement the class `LRUCache` with the following methods:

– `get(key: int) -> int`: Return the value of the key if it exists, otherwise return -1.

– `put(key: int, value: int) -> None`: Update the value of the key if it exists, or insert the key-value pair if it doesn’t. When the cache reaches its capacity, it should invalidate the item that has been used least recently.

The cache should operate in O(1) time complexity for both operations.

o3 程式碼:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
class Node:
"""Doubly‑linked‑list node holding a cache entry (key, value)."""
__slots__ = ("key", "value", "prev", "next")
def __init__(self, key: int, value: int):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
def __init__(self, capacity: int):
if capacity <= 0:
raise ValueError("Capacity must be positive")
self.cap = capacity
self.map: dict[int, Node] = {}
# Dummy head/tail simplify edge‑case handling
self.head = Node(0, 0) # Most‑recently‑used sentinel
self.tail = Node(0, 0) # Least‑recently‑used sentinel
self.head.next = self.tail
self.tail.prev = self.head
# ───────────────────────── Internal helpers ──────────────────────────
def _add_to_front(self, node: Node) -> None:
"""Insert node right after head (MRU position)."""
node.prev = self.head
node.next = self.head.next
self.head.next.prev = node
self.head.next = node
def _remove(self, node: Node) -> None:
"""Unlink node from list."""
node.prev.next = node.next
node.next.prev = node.prev
# ───────────────────────── Public API ────────────────────────────────
def get(self, key: int) -> int:
"""Return value if present; else ‑1. Marks entry as recently used."""
if key not in self.map:
return -1
node = self.map[key]
self._remove(node)
self._add_to_front(node)
return node.value
def put(self, key: int, value: int) -> None:
"""
Insert/update (key,value).
If capacity exceeded, evict the least‑recently‑used entry.
"""
if key in self.map: # Update existing
node = self.map[key]
node.value = value
self._remove(node)
self._add_to_front(node)
return
# Insert new key
node = Node(key, value)
self.map[key] = node
self._add_to_front(node)
# Evict if over capacity
if len(self.map) > self.cap:
lru = self.tail.prev # Real LRU node
self._remove(lru)
del self.map[lru.key]
class Node: """Doubly‑linked‑list node holding a cache entry (key, value).""" __slots__ = ("key", "value", "prev", "next") def __init__(self, key: int, value: int): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity: int): if capacity <= 0: raise ValueError("Capacity must be positive") self.cap = capacity self.map: dict[int, Node] = {} # Dummy head/tail simplify edge‑case handling self.head = Node(0, 0) # Most‑recently‑used sentinel self.tail = Node(0, 0) # Least‑recently‑used sentinel self.head.next = self.tail self.tail.prev = self.head # ───────────────────────── Internal helpers ────────────────────────── def _add_to_front(self, node: Node) -> None: """Insert node right after head (MRU position).""" node.prev = self.head node.next = self.head.next self.head.next.prev = node self.head.next = node def _remove(self, node: Node) -> None: """Unlink node from list.""" node.prev.next = node.next node.next.prev = node.prev # ───────────────────────── Public API ──────────────────────────────── def get(self, key: int) -> int: """Return value if present; else ‑1. Marks entry as recently used.""" if key not in self.map: return -1 node = self.map[key] self._remove(node) self._add_to_front(node) return node.value def put(self, key: int, value: int) -> None: """ Insert/update (key,value). If capacity exceeded, evict the least‑recently‑used entry. """ if key in self.map: # Update existing node = self.map[key] node.value = value self._remove(node) self._add_to_front(node) return # Insert new key node = Node(key, value) self.map[key] = node self._add_to_front(node) # Evict if over capacity if len(self.map) > self.cap: lru = self.tail.prev # Real LRU node self._remove(lru) del self.map[lru.key]
class Node:
"""Doubly‑linked‑list node holding a cache entry (key, value)."""
__slots__ = ("key", "value", "prev", "next")
def __init__(self, key: int, value: int):
self.key   = key
self.value = value
self.prev  = None
self.next  = None
class LRUCache:
def __init__(self, capacity: int):
if capacity <= 0:
raise ValueError("Capacity must be positive")
self.cap = capacity
self.map: dict[int, Node] = {}
# Dummy head/tail simplify edge‑case handling
self.head = Node(0, 0)          # Most‑recently‑used sentinel
self.tail = Node(0, 0)          # Least‑recently‑used sentinel
self.head.next = self.tail
self.tail.prev = self.head
# ───────────────────────── Internal helpers ──────────────────────────
def _add_to_front(self, node: Node) -> None:
"""Insert node right after head (MRU position)."""
node.prev        = self.head
node.next        = self.head.next
self.head.next.prev = node
self.head.next      = node
def _remove(self, node: Node) -> None:
"""Unlink node from list."""
node.prev.next = node.next
node.next.prev = node.prev
# ───────────────────────── Public API ────────────────────────────────
def get(self, key: int) -> int:
"""Return value if present; else ‑1. Marks entry as recently used."""
if key not in self.map:
return -1
node = self.map[key]
self._remove(node)
self._add_to_front(node)
return node.value
def put(self, key: int, value: int) -> None:
"""
Insert/update (key,value).  
If capacity exceeded, evict the least‑recently‑used entry.
"""
if key in self.map:                        # Update existing
node = self.map[key]
node.value = value
self._remove(node)
self._add_to_front(node)
return
# Insert new key
node = Node(key, value)
self.map[key] = node
self._add_to_front(node)
# Evict if over capacity
if len(self.map) > self.cap:
lru = self.tail.prev                  # Real LRU node
self._remove(lru)
del self.map[lru.key]

o4-mini 程式碼:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
class Node:
__slots__ = ('key', 'value', 'prev', 'next')
def __init__(self, key: int = None, value: int = None):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
def __init__(self, capacity: int):
self.capacity = capacity
self.cache = {} # key → Node
# Dummy head/tail
self.head = Node()
self.tail = Node()
self.head.next = self.tail
self.tail.prev = self.head
def _remove(self, node: Node):
"""Disconnect node from list."""
prev, nxt = node.prev, node.next
prev.next = nxt
nxt.prev = prev
def _add_to_front(self, node: Node):
"""Insert node right after head."""
node.next = self.head.next
node.prev = self.head
self.head.next.prev = node
self.head.next = node
def get(self, key: int) -> int:
if key not in self.cache:
return -1
node = self.cache[key]
# Move to front
self._remove(node)
self._add_to_front(node)
return node.value
def put(self, key: int, value: int) -> None:
if key in self.cache:
# Update existing node and move it to front
node = self.cache[key]
node.value = value
self._remove(node)
self._add_to_front(node)
else:
# Insert new node
new_node = Node(key, value)
self.cache[key] = new_node
self._add_to_front(new_node)
# Evict LRU if over capacity
if len(self.cache) > self.capacity:
# Tail.prev is LRU
lru = self.tail.prev
self._remove(lru)
del self.cache[lru.key]
class Node: __slots__ = ('key', 'value', 'prev', 'next') def __init__(self, key: int = None, value: int = None): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity: int): self.capacity = capacity self.cache = {} # key → Node # Dummy head/tail self.head = Node() self.tail = Node() self.head.next = self.tail self.tail.prev = self.head def _remove(self, node: Node): """Disconnect node from list.""" prev, nxt = node.prev, node.next prev.next = nxt nxt.prev = prev def _add_to_front(self, node: Node): """Insert node right after head.""" node.next = self.head.next node.prev = self.head self.head.next.prev = node self.head.next = node def get(self, key: int) -> int: if key not in self.cache: return -1 node = self.cache[key] # Move to front self._remove(node) self._add_to_front(node) return node.value def put(self, key: int, value: int) -> None: if key in self.cache: # Update existing node and move it to front node = self.cache[key] node.value = value self._remove(node) self._add_to_front(node) else: # Insert new node new_node = Node(key, value) self.cache[key] = new_node self._add_to_front(new_node) # Evict LRU if over capacity if len(self.cache) > self.capacity: # Tail.prev is LRU lru = self.tail.prev self._remove(lru) del self.cache[lru.key]
class Node:
__slots__ = ('key', 'value', 'prev', 'next')
def __init__(self, key: int = None, value: int = None):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
def __init__(self, capacity: int):
self.capacity = capacity
self.cache = {}               # key → Node
# Dummy head/tail
self.head = Node()
self.tail = Node()
self.head.next = self.tail
self.tail.prev = self.head
def _remove(self, node: Node):
"""Disconnect node from list."""
prev, nxt = node.prev, node.next
prev.next = nxt
nxt.prev = prev
def _add_to_front(self, node: Node):
"""Insert node right after head."""
node.next = self.head.next
node.prev = self.head
self.head.next.prev = node
self.head.next = node
def get(self, key: int) -> int:
if key not in self.cache:
return -1
node = self.cache[key]
# Move to front
self._remove(node)
self._add_to_front(node)
return node.value
def put(self, key: int, value: int) -> None:
if key in self.cache:
# Update existing node and move it to front
node = self.cache[key]
node.value = value
self._remove(node)
self._add_to_front(node)
else:
# Insert new node
new_node = Node(key, value)
self.cache[key] = new_node
self._add_to_front(new_node)
# Evict LRU if over capacity
if len(self.cache) > self.capacity:
# Tail.prev is LRU
lru = self.tail.prev
self._remove(lru)
del self.cache[lru.key]

Gemini 2.5 程式碼:

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
import collections
class Node:
"""Node for the doubly linked list."""
def __init__(self, key, value):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
def __init__(self, capacity: int):
if capacity <= 0:
raise ValueError("Capacity must be a positive integer")
self.capacity = capacity
self.cache = {} # Stores key -> Node mapping
# Initialize sentinel nodes for the doubly linked list
self.head = Node(0, 0) # Dummy head
self.tail = Node(0, 0) # Dummy tail
self.head.next = self.tail
self.tail.prev = self.head
def _remove_node(self, node: Node):
"""Removes an existing node from the linked list."""
prev_node = node.prev
next_node = node.next
prev_node.next = next_node
next_node.prev = prev_node
# Optional: clear node pointers for garbage collection if needed
# node.prev = None
# node.next = None
def _add_to_front(self, node: Node):
"""Adds a node right after the head (most recently used)."""
node.prev = self.head
node.next = self.head.next
self.head.next.prev = node
self.head.next = node
def get(self, key: int) -> int:
"""
Return the value of the key if it exists, otherwise return -1.
Moves the accessed node to the front (most recently used).
"""
if key in self.cache:
node = self.cache[key]
# Move accessed node to the front
self._remove_node(node)
self._add_to_front(node)
return node.value
else:
return -1
def put(self, key: int, value: int) -> None:
"""
Update the value of the key if it exists, or insert the key-value pair.
Moves the updated/inserted node to the front.
Evicts the least recently used item if capacity is exceeded.
"""
if key in self.cache:
# Key exists, update value and move to front
node = self.cache[key]
node.value = value
self._remove_node(node)
self._add_to_front(node)
else:
# Key doesn't exist, insert new node
new_node = Node(key, value)
self.cache[key] = new_node
self._add_to_front(new_node)
# Check if capacity is exceeded
if len(self.cache) > self.capacity:
# Evict the least recently used item (node before tail)
lru_node = self.tail.prev
self._remove_node(lru_node)
# Remove from cache as well
del self.cache[lru_node.key]
# Example Usage:
try:
cache = LRUCache(2)
cache.put(1, 1) # cache is {1=1}
print(f"Cache after put(1, 1): {[(k, v.value) for k, v in cache.cache.items()]}")
cache.put(2, 2) # cache is {1=1, 2=2}
print(f"Cache after put(2, 2): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(1): {cache.get(1)}") # returns 1, cache is {2=2, 1=1} (1 is now MRU)
print(f"Cache after get(1): {[(k, v.value) for k, v in cache.cache.items()]}") # Order in dict might not reflect LRU order
cache.put(3, 3) # LRU key 2 was evicted, cache is {1=1, 3=3}
print(f"Cache after put(3, 3): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(2): {cache.get(2)}") # returns -1 (not found)
cache.put(4, 4) # LRU key 1 was evicted, cache is {3=3, 4=4}
print(f"Cache after put(4, 4): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(1): {cache.get(1)}") # returns -1 (not found)
print(f"get(3): {cache.get(3)}") # returns 3
print(f"Cache after get(3): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(4): {cache.get(4)}") # returns 4
print(f"Cache after get(4): {[(k, v.value) for k, v in cache.cache.items()]}")
except ValueError as e:
print(f"Error: {e}")
import collections class Node: """Node for the doubly linked list.""" def __init__(self, key, value): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity: int): if capacity <= 0: raise ValueError("Capacity must be a positive integer") self.capacity = capacity self.cache = {} # Stores key -> Node mapping # Initialize sentinel nodes for the doubly linked list self.head = Node(0, 0) # Dummy head self.tail = Node(0, 0) # Dummy tail self.head.next = self.tail self.tail.prev = self.head def _remove_node(self, node: Node): """Removes an existing node from the linked list.""" prev_node = node.prev next_node = node.next prev_node.next = next_node next_node.prev = prev_node # Optional: clear node pointers for garbage collection if needed # node.prev = None # node.next = None def _add_to_front(self, node: Node): """Adds a node right after the head (most recently used).""" node.prev = self.head node.next = self.head.next self.head.next.prev = node self.head.next = node def get(self, key: int) -> int: """ Return the value of the key if it exists, otherwise return -1. Moves the accessed node to the front (most recently used). """ if key in self.cache: node = self.cache[key] # Move accessed node to the front self._remove_node(node) self._add_to_front(node) return node.value else: return -1 def put(self, key: int, value: int) -> None: """ Update the value of the key if it exists, or insert the key-value pair. Moves the updated/inserted node to the front. Evicts the least recently used item if capacity is exceeded. """ if key in self.cache: # Key exists, update value and move to front node = self.cache[key] node.value = value self._remove_node(node) self._add_to_front(node) else: # Key doesn't exist, insert new node new_node = Node(key, value) self.cache[key] = new_node self._add_to_front(new_node) # Check if capacity is exceeded if len(self.cache) > self.capacity: # Evict the least recently used item (node before tail) lru_node = self.tail.prev self._remove_node(lru_node) # Remove from cache as well del self.cache[lru_node.key] # Example Usage: try: cache = LRUCache(2) cache.put(1, 1) # cache is {1=1} print(f"Cache after put(1, 1): {[(k, v.value) for k, v in cache.cache.items()]}") cache.put(2, 2) # cache is {1=1, 2=2} print(f"Cache after put(2, 2): {[(k, v.value) for k, v in cache.cache.items()]}") print(f"get(1): {cache.get(1)}") # returns 1, cache is {2=2, 1=1} (1 is now MRU) print(f"Cache after get(1): {[(k, v.value) for k, v in cache.cache.items()]}") # Order in dict might not reflect LRU order cache.put(3, 3) # LRU key 2 was evicted, cache is {1=1, 3=3} print(f"Cache after put(3, 3): {[(k, v.value) for k, v in cache.cache.items()]}") print(f"get(2): {cache.get(2)}") # returns -1 (not found) cache.put(4, 4) # LRU key 1 was evicted, cache is {3=3, 4=4} print(f"Cache after put(4, 4): {[(k, v.value) for k, v in cache.cache.items()]}") print(f"get(1): {cache.get(1)}") # returns -1 (not found) print(f"get(3): {cache.get(3)}") # returns 3 print(f"Cache after get(3): {[(k, v.value) for k, v in cache.cache.items()]}") print(f"get(4): {cache.get(4)}") # returns 4 print(f"Cache after get(4): {[(k, v.value) for k, v in cache.cache.items()]}") except ValueError as e: print(f"Error: {e}")
import collections
class Node:
"""Node for the doubly linked list."""
def __init__(self, key, value):
self.key = key
self.value = value
self.prev = None
self.next = None
class LRUCache:
def __init__(self, capacity: int):
if capacity <= 0:
raise ValueError("Capacity must be a positive integer")
self.capacity = capacity
self.cache = {}  # Stores key -> Node mapping
# Initialize sentinel nodes for the doubly linked list
self.head = Node(0, 0) # Dummy head
self.tail = Node(0, 0) # Dummy tail
self.head.next = self.tail
self.tail.prev = self.head
def _remove_node(self, node: Node):
"""Removes an existing node from the linked list."""
prev_node = node.prev
next_node = node.next
prev_node.next = next_node
next_node.prev = prev_node
# Optional: clear node pointers for garbage collection if needed
# node.prev = None
# node.next = None
def _add_to_front(self, node: Node):
"""Adds a node right after the head (most recently used)."""
node.prev = self.head
node.next = self.head.next
self.head.next.prev = node
self.head.next = node
def get(self, key: int) -> int:
"""
Return the value of the key if it exists, otherwise return -1.
Moves the accessed node to the front (most recently used).
"""
if key in self.cache:
node = self.cache[key]
# Move accessed node to the front
self._remove_node(node)
self._add_to_front(node)
return node.value
else:
return -1
def put(self, key: int, value: int) -> None:
"""
Update the value of the key if it exists, or insert the key-value pair.
Moves the updated/inserted node to the front.
Evicts the least recently used item if capacity is exceeded.
"""
if key in self.cache:
# Key exists, update value and move to front
node = self.cache[key]
node.value = value
self._remove_node(node)
self._add_to_front(node)
else:
# Key doesn't exist, insert new node
new_node = Node(key, value)
self.cache[key] = new_node
self._add_to_front(new_node)
# Check if capacity is exceeded
if len(self.cache) > self.capacity:
# Evict the least recently used item (node before tail)
lru_node = self.tail.prev
self._remove_node(lru_node)
# Remove from cache as well
del self.cache[lru_node.key]
# Example Usage:
try:
cache = LRUCache(2)
cache.put(1, 1)       # cache is {1=1}
print(f"Cache after put(1, 1): {[(k, v.value) for k, v in cache.cache.items()]}")
cache.put(2, 2)       # cache is {1=1, 2=2}
print(f"Cache after put(2, 2): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(1): {cache.get(1)}")       # returns 1, cache is {2=2, 1=1} (1 is now MRU)
print(f"Cache after get(1): {[(k, v.value) for k, v in cache.cache.items()]}") # Order in dict might not reflect LRU order
cache.put(3, 3)       # LRU key 2 was evicted, cache is {1=1, 3=3}
print(f"Cache after put(3, 3): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(2): {cache.get(2)}")       # returns -1 (not found)
cache.put(4, 4)       # LRU key 1 was evicted, cache is {3=3, 4=4}
print(f"Cache after put(4, 4): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(1): {cache.get(1)}")       # returns -1 (not found)
print(f"get(3): {cache.get(3)}")       # returns 3
print(f"Cache after get(3): {[(k, v.value) for k, v in cache.cache.items()]}")
print(f"get(4): {cache.get(4)}")       # returns 4
print(f"Cache after get(4): {[(k, v.value) for k, v in cache.cache.items()]}")
except ValueError as e:
print(f"Error: {e}")

輸出結果對比

標準 o3 o4-mini Gemini 2.5
可讀性
出色的結構和註釋 非常簡潔,可讀性較差 清晰明瞭的註釋
設計與模組化 良好的模組化,使用私有方法 簡約,缺乏模組安全性 模組化的輔助方法和檢查
效能 使用 __slots__和哨兵達到最佳效果 最優,記憶體效率高 最最佳化,提供可選的 GC 建議
安全性和魯棒性 強大的驗證和簡潔的錯誤處理 缺乏輸入檢查(如容量 ≤ 0) 包括驗證和安全保護

最終結論

o3 在可讀性、安全性、設計和效能方面實現了最佳平衡,因此最適合生產和長期使用。

任務 4:建立網頁

輸入提示: Design a responsive personal portfolio webpage using HTML and CSS. The page should include the following sections:

1. Header: Display the user’s name and a brief tagline.

2. About Me: A short paragraph describing the user’s background and skills.

3. Projects: Showcase at least three projects with titles, descriptions, and links.

4. Contact: Provide contact information or a contact form.

Ensure the design is clean and mobile-friendly. Use semantic HTML elements and include basic CSS styling to enhance the visual appeal. Avoid using external CSS frameworks; write custom CSS for styling.

Implement the webpage in a single HTML file with embedded CSS.

o3 輸出:

o3建立網頁

o4-mini 輸出:

o4-mini建立網頁

Gemini 2.5 輸出:

Gemini 2.5建立網頁

輸出結果對比

特徵 o3 o4-mini Gemini 2.5
設計美學 現代、多彩的漸變標題和統一的主題顏色 乾淨簡約,有基本的邊框和框陰影 佈局簡潔,設計極簡。利用容器寬度和襯墊實現響應性。
程式碼結構和語義 出色地使用語義 HTML 和註釋;統一的 BEM 風格類命名 簡潔的語義 HTML,但較少模組化或註釋 結構合理,HTML、CSS 和 JS 分離清晰。注重語義 HTML,正確使用 <header>、<section> 和 <footer> 等元素。
響應性 透過 clamp()、自動適應網格和媒體查詢實現高度響應 利用 flex-wrap 和簡單的媒體查詢實現基本的響應性 良好的響應性,可針對各種螢幕尺寸進行動態調整,確保在各種裝置上都能獲得適當的使用者體驗。
包含的功能 功能齊全:頁首、關於、專案網格、聯絡方式(表單和資訊)、簡潔的頁尾 類似的部分,但在佈局、互動性和樣式的精細度方面缺乏打磨 類似的部分,但在佈局、互動性和造型方面缺乏精細度

最終結論

它的使用者介面更精緻,響應速度更快,採用了現代 CSS 技術(如變數和箝位),整體呈現更專業。它可用於生產,並展示了對 CSS 的深入掌握。

任務 5:影像分析

輸入影像:

彩虹的形成過程

輸入提示詞:Explain the image to me in simple words, around 60 words

o3 輸出:

o3解釋彩虹的形成過程

o4-mini 輸出:

o4-mini解釋彩虹的形成過程

Gemini 2.5 輸出:

Gemini 2.5解釋彩虹的形成過程

輸出結果對比

對比項 o3輸出 o4-mini輸出 Gemini 2.5輸出
清晰度 清晰、簡單、易懂。 略微詳細,仍然清晰。 簡單易懂。
解釋深度 平衡的解釋,包含重要細節。 更詳細地說明顏色如何彎曲。 對概念的解釋非常基本。
語調/風格 中立、科學,但又通俗易懂。 略微娓娓道來,依然正式。 非常有教育意義,便於快速理解。
長度 緊湊、簡潔,涵蓋所有要點。 更長,更有深度。 非常簡短,切中要害。

最終結論

o3 輸出在清晰、完整和簡潔之間取得了最佳平衡,非常適合普通讀者。它清晰地解釋了彩虹的形成過程,沒有過多的細節讓讀者不知所措,同時還涵蓋了折射、內部反射以及多個水滴如何形成彩虹效果等基本方面。其簡潔的風格使其易於消化和理解,是解釋彩虹現象最有效的選擇。

總體評價

O3 是各方面綜合表現最好的。它在科學準確和通俗易懂之間取得了完美的平衡。Gemini 2.5 適合非常基礎的理解,O4-mini 適合技術性較強的讀者,而 O3 則最適合普通讀者和教育目的,它提供了完整而引人入勝的解釋,同時又不會過於技術化或過於簡單化。

基準比較

為了更好地瞭解尖端人工智慧模型的效能,讓我們透過一系列標準化基準對 Gemini 2.5 Pro、o4-mini 和 o3 進行比較。這些基準評估了模型的各種能力,從高等數學和物理學到軟體工程和複雜推理。

基準比較

主要收穫

  • 數學推理:o4-mini 在 AIME 2024(93.4%)和 AIME 2025(92.7%)中遙遙領先,略高於 o3 和 Gemini 2.5 Pro。
  • 物理知識:Gemini 2.5 Pro 在 GPQA 中得分最高(84%),表明其在研究生水平的物理學領域具有很強的專業知識。
  • 複雜推理挑戰:所有模型都在“人類最後一次考試”中表現不佳(<21%),其中 o3 表現最好,僅為 20.3%。
  • 軟體工程:o3 在 SWE-Bench 考試中取得 69.1%,超過 o4-mini(68.1%)和 Gemini 2.5 Pro(63.8%)。
  • 多模態任務:o3 在 MMMU(82.9%)中也名列前茅,但差距不大。

解釋和影響

這些結果凸顯了每個模型的優勢:o4-mini 在結構化數學基準方面表現出色,Gemini 2.5 Pro 在專業物理方面大放異彩,而 o3 則在編碼和多模態理解方面表現出均衡的能力。在 “人類最後的考試 ”中得分較低,這表明在抽象推理任務方面還有改進的餘地。

小結

歸根結底,o3、o4-mini 和 Gemini 2.5 Pro 這三種模型都代表了人工智慧推理的最前沿,而且各有所長。o3 憑藉其影像驅動的思維鏈和在各種基準測試中的強勁效能,在軟體工程、深度分析任務和多模態理解方面表現出色。

Gemini 2.5 Pro 的超大上下文視窗和對文字、影像、音訊和影片的本地支援,使其在研究生物理和大規模多模態工作流中具有明顯優勢。在它們之間做出選擇取決於您的具體需求(例如,使用 o3 進行深度分析,使用 o4-mini 進行快速數學精度分析,或使用 Gemini 2.5 Pro 進行大規模多模態推理),但無論如何,這些模型都在重新定義人工智慧的功能。

常見問題

O 模型(O3、O4-mini)與 Gemini 2.5 的主要區別是什麼?

Gemini 2.5 pro 支援多達 200 萬個片語的上下文視窗,明顯大於 O 模型。

哪種模型更適合編碼任務?O 模型還是 Gemini 2.5?

在高階編碼和軟體工程任務中,O3 和 O4-mini 通常優於 Gemini 2.5。不過,在需要大上下文視窗或多模態輸入的編碼專案中,Gemini 2.5 更受青睞。

這些模型的價格比較如何?

就輸入和輸出令牌而言,Gemini 2.5 Pro 的成本效益大約是 O3 的 4.4 倍。這使得 Gemini 2.5 成為大規模或預算有限的應用程式的首選。

這些模型的上下文視窗尺寸是多少?

Gemini 2.5 Pro:高達 200 萬個標記O3 和 O4-mini:通常支援高達 20 萬個標記Gemini 的超大上下文視窗使其能夠一次性處理更大的文件或資料集。

所有這些模型都支援多模態嗎?

是的,但有一些關鍵區別:O3 和 O4-mini 包括視覺功能(影像輸入)。Gemini 2.5 Pro 本身具有多模態功能,可處理文字、影像、音訊和影片,因此在處理跨模態任務時用途更廣。

評論留言