Uber OA HackerRank 平台真題實錄：環境差異 + 真題復盤 + 平台坑位

Uber 的 OA 幾乎全部在 HackerRank 平台上發，但很多同學第一次進 HackerRank 都被環境差異坑過——IDE 沒有 LSP，提交後才看到 hidden case，時間複雜度跑不過部分 case 直接零分。這些都不是題目本身的問題，而是對平台的理解不夠。

這篇文章不再講演算法，而是把 HackerRank 平台本身當主角：環境差異、IO 模板、隱藏 case 評分邏輯、以及兩道完全圍繞平台特性設計的 Uber 真題復盤——Trip Cost Reconstruction（TLE 陷阱）+ Driver Match Window（IO 邊界陷阱）。讀完你應該能在面試日少踩 80% 平台坑。

HackerRank vs CoderPad vs LeetCode：環境差異速查表

維度	HackerRank	CoderPad	LeetCode
編輯器 LSP	有限（語法高亮）	完整	完整
自動補全	無	有	有
測試案例	公開 + Hidden	公開	公開 + Hidden
評分邏輯	AC 案例數	面試官打分	全 AC 才過
時間限制	通常 4-10 秒	無	通常 1-2 秒
IO 模板	必須自己讀	函式簽名	函式簽名

關鍵差異：HackerRank 的 IO 模板必須自己讀 stdin，這一點比 LeetCode 麻煩很多——很多同學在第一題因為 IO 解析卡 20 分鐘。

HackerRank Python IO 標準模板

輸入：N 個整數 + N 行字串

import sys
input = sys.stdin.readline

def solve():
    n = int(input())
    nums = list(map(int, input().split()))
    strs = [input().strip() for _ in range(n)]
    # ... your logic
    print(answer)

solve()

坑位：

• sys.stdin.readline 比 input() 快 5-10 倍
• 用 strip() 去掉換行符
• 大資料輸出用 sys.stdout.write 或 '\n'.join(map(str, results))

真題復盤 1：Trip Cost Reconstruction（TLE 陷阱）

給 N 筆訂單的起點 / 終點 / 價格 (from, to, price)，給 Q 個查詢 (u, v)，回傳從 u 到 v 是否能走通（不一定是直達，可以中轉），最低總價多少。N ≤ 1e4，Q ≤ 1e3。

錯誤解法（HackerRank 上 TLE）

每次查詢都跑一次 Dijkstra：

def query_naive(graph, u, v):
    # Dijkstra from u
    ...

複雜度：每次查詢 O((V+E) log V)，Q 次合計 O(Q · (V+E) log V) = 在 N=1e4, Q=1e3 時，約 1e8，4 秒時限 TLE。

正確解法：Floyd-Warshall 預處理

def trip_costs(N, edges, queries):
    INF = float("inf")
    dist = [[INF] * N for _ in range(N)]
    for i in range(N):
        dist[i][i] = 0
    for u, v, w in edges:
        dist[u][v] = min(dist[u][v], w)
    for k in range(N):
        for i in range(N):
            if dist[i][k] == INF: continue
            for j in range(N):
                if dist[i][k] + dist[k][j] < dist[i][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]
    return [dist[u][v] if dist[u][v] != INF else -1 for u, v in queries]

複雜度：O(N^3) = 1e12——也 TLE！需要進一步優化。

最終解法：Johnson + 多源 Dijkstra

實際通過解：在 Q 較小時，可以只對 Q 個查詢的源點跑 Dijkstra（Q 次），而不是預處理 N×N。

import heapq
from collections import defaultdict

def trip_costs_final(N, edges, queries):
    g = defaultdict(list)
    for u, v, w in edges:
        g[u].append((v, w))

    def dijkstra(src):
        INF = float("inf")
        d = [INF] * N
        d[src] = 0
        h = [(0, src)]
        while h:
            cur, u = heapq.heappop(h)
            if cur > d[u]: continue
            for v, w in g[u]:
                if cur + w < d[v]:
                    d[v] = cur + w
                    heapq.heappush(h, (d[v], v))
        return d

    cache = {}
    res = []
    for u, v in queries:
        if u not in cache:
            cache[u] = dijkstra(u)
        d = cache[u][v]
        res.append(d if d != float("inf") else -1)
    return res

複雜度：O(Q_unique · (V+E) log V)，去重後通常 ≤ 5e7，能過。 HackerRank 平台坑：預設 Python 沒有 PyPy 加速，Dijkstra 必須用 heapq 而不是 SortedList。

真題復盤 2：Driver Match Window（IO 邊界陷阱）

輸入：第一行 N M，下面 N 行每行一個司機 (driver_id, lat, lon, capacity)，下面 M 行每行一個乘客 (rider_id, lat, lon)。要求每個乘客匹配最近的有 capacity 的司機，回傳 (rider_id, driver_id) 的配對列表。

IO 邊界陷阱

import sys
input = sys.stdin.readline

def solve():
    line1 = input().split()
    N, M = int(line1[0]), int(line1[1])
    drivers = []
    for _ in range(N):
        parts = input().split()
        # HackerRank 輸入可能有 trailing whitespace
        drivers.append((parts[0], float(parts[1]), float(parts[2]), int(parts[3])))
    riders = []
    for _ in range(M):
        parts = input().split()
        riders.append((parts[0], float(parts[1]), float(parts[2])))

    res = []
    available = {d[0]: d[3] for d in drivers}
    for rid, rlat, rlon in riders:
        best = None
        best_dist = float("inf")
        for did, dlat, dlon, _ in drivers:
            if available[did] <= 0: continue
            d = (rlat-dlat)**2 + (rlon-dlon)**2
            if d < best_dist:
                best_dist = d
                best = did
        if best:
            available[best] -= 1
            res.append((rid, best))
    print('\n'.join(f"{r} {d}" for r, d in res))

solve()

HackerRank 平台坑：

• 輸入行可能有 trailing whitespace —— split() 預設會處理，但**split(' ')** 會留空字串
• parts[0] 是字串，不需要 int() —— 題目裡 driver_id 可能是 hex 或 UUID
• 輸出末尾可能需要換行符——HackerRank 嚴格判等

複雜度：O(N·M)，N=M=1e3 時 1e6 OK；如果 N=M=1e5 必須用 KD-Tree 或網格雜湊。

HackerRank 評分邏輯：你必須知道的 5 件事

1. AC 案例數累加：每過一個 hidden case 加幾分，不全 AC 也能拿分
2. TLE 不計分：案例 TLE 直接 0 分，所以慢演算法不如不交
3. 執行 vs 提交：執行只跑前 3-5 個公開 case，hidden case 必須靠提交
4. 不能反覆提交：部分批次限制提交次數（一般 3-5 次）
5. 時間限制因語言而異：Python 通常是 C++ 的 2-3 倍

面試日清單

考前 30 分鐘：

• 網路穩定性測試（HackerRank 卡頓會丟失程式碼）
• 關閉所有干擾應用（防毒、自動更新）
• 準備 IO 模板程式碼片段
• 瀏覽器 zoom 100%（避免誤點）

考中：

• 通讀全部題面後再開始
• 第一題不要追求最優，先 AC sample
• 每寫完一段程式碼立即點 Run

考後：

• 看到「Submitted」再關瀏覽器
• 截圖 / 記錄題面便於事後復盤

FAQ

Q1：HackerRank 卡頓丟程式碼怎麼辦？ HackerRank 有自動儲存，但建議每 5 分鐘手動 Ctrl+A + Ctrl+C 複製到本地編輯器作為備份。

Q2：Python 解 TLE 太多，能換 C++ 嗎？ 能。Uber OA 允許多語言切換，但切換會重置編輯器，建議進考場前就決定好語言。

Q3：HackerRank 偵測作弊嗎？ 有攝影機監考的批次會偵測；純 OA 批次不強。但全螢幕切換 / 複製貼上外部內容 會被記錄。

Q4：Hidden case 跑超時但 sample 過了，怎麼辦？ 幾乎肯定是複雜度問題。回頭檢查：巢狀迴圈 / 遞迴無 memo / 字串拼接用 + 而非 join。

Q5：HackerRank 的 OA 連結 24 小時後失效嗎？ 不一定。連結通常有 5-7 天有效期，但點開後會有 90 分鐘倒數計時——點開就必須做完。

---

正在準備 Uber HackerRank OA？

如果你 IO 模板還沒練熟、TLE 反覆出現，或希望面試日有真人 OA代面 / VO代面 做平台環境檢查與同步陪跑，可以聊聊看完整的 OA輔助 / VO輔助 方案。

---

聯絡方式

需要面試真題與客製備戰計畫？立刻聯絡微信 Coding0201，獲取真題。

Email: [email protected] Telegram: @OAVOProxy