🚨 ZipRecruiter 2026 OA 真題：最長公共後綴路徑 —— New Grad 必刷，路徑簡化 + 後綴匹配雙重考驗！

ZipRecruiter OA 概覽

今天給大家講講 ZipRecruiter OA New Grad 的線上測評經驗。

ZipRecruiter OA 對於剛畢業的同學來說，難度適中，但非常考驗邏輯思維和細節處理能力。我助攻過很多批次的 ZipRecruiter OA，發現它和其他公司風格不太一樣：它不追求複雜的演算法實現，而是更看重你能否快速理清思路、正確處理邊界和分類問題。

ZipRecruiter OA 流程

ZipRecruiter 的 Online Assessment（OA）通常分為 1–2 輪，大部分 New Grad 面試生會遇到單輪 OA：

項目	詳情
總時長	50–70 分鐘（最近多為 70min）
題量	2–4 道
平台	CodeSignal（General Coding Assessment）
支援語言	Python、Java、C++ 等主流語言

OA 核心特點

題量適中：不像一些大廠 OA 那樣題目多，但每道題都考察你的思路和細節敏感度
邏輯為王：比起寫超複雜演算法，更看重思路清晰、邊界處理和分類能力
資料處理題居多：陣列、匹配問題、貪心策略、排序和雙指標都是常見套路

ZipRecruiter OA FAQ（2026 年最新經驗彙總）

問題	答案
Q1: 平台？	CodeSignal（General Coding Assessment）
Q2: 題數與時間？	4 題，60-70 分鐘（最近多為 70min）
Q3: 是否監考？	部分批次需開攝影機+螢幕共享（proctored），邀請郵件會說明
Q4: 難度？	LeetCode Easy ~ Medium（前 2-3 易，第 4 題 Medium）
Q5: 常見題型？	陣列/字串、雜湊表、模擬、雙指標、簡單 DP（偶爾多部分實現題）
Q6: 通過標準？	無官方閾值，700+ 分較安全（注重速度+正確率）；高分也可能因簡歷/需求被拒
Q7: 如何準備？	刷 CodeSignal 練習 + LeetCode Easy/Medium；練 70min 內 AC 4 題
Q8: 通過後流程？	Recruiter Call → Technical Screen → Onsite

題目拆解：最長公共後綴路徑

🔍 原題描述

You are given an array of strings paths containing paths to some files or directories. All file paths start with "/".

Note: File paths may contain special characters ".." to represent parent directory specifiers. For example, "/a/b/../" points to the same directory as "/a". It is guaranteed that all given file paths are valid.

Your task is to find the longest common suffix path without file masks or special characters (e.g., "..", etc.). If there isn't any common suffix path, return an empty string as "".

📝 中文翻譯

給定一個字串陣列 paths，包含若干檔案或目錄的路徑。所有路徑都以 "/" 開頭。

注意：路徑可能包含特殊字元 ".." 表示父目錄。例如，"/a/b/../" 等價於 "/a"。

任務：找到所有路徑的最長公共後綴路徑，返回時不包含特殊字元。如果沒有公共後綴，返回空字串。

🎯 範例分析

輸入：

paths = [
    "/a/folder1/../folder1/a/leaf.txt",
    "/b/folder2/../folder1/a/leaf.txt",
    "/a/folder3/folder1/folder1/../a/leaf.txt"
]

輸出：

"/folder1/a/leaf.txt"

解釋：

首先簡化每個路徑（解析 ..）：

原始路徑	簡化後
`/a/folder1/../folder1/a/leaf.txt`	`/a/folder1/a/leaf.txt`
`/b/folder2/../folder1/a/leaf.txt`	`/b/folder1/a/leaf.txt`
`/a/folder3/folder1/folder1/../a/leaf.txt`	`/a/folder3/folder1/a/leaf.txt`

從末尾開始比較：

leaf.txt ✓ 相同
a ✓ 相同
folder1 ✓ 相同
第 3 層：a vs b vs folder3 ✗ 不同

因此，最長公共後綴路徑是 /folder1/a/leaf.txt。

深度複盤：題目本質

這道題考察兩個核心能力：

考點	具體內容
路徑簡化	處理 `..` 返回上一級目錄
後綴匹配	從末尾開始找最長公共部分
邊界處理	空路徑、全相同、無公共後綴
字串分割	按 `/` 分割成路徑組件

關鍵洞察

路徑簡化：用堆疊模擬目錄遍歷，遇到 .. 就彈出
後綴匹配：將路徑組件反轉，找最長公共前綴（LCP），再反轉回來
注意：輸出要以 / 開頭

方案引入：核心演算法

解法：路徑簡化 + 後綴 LCP

def solution(paths: list) -> str:
    """
    ZipRecruiter OA 真題：最長公共後綴路徑
    
    Args:
        paths: 檔案路徑陣列
    
    Returns:
        str: 最長公共後綴路徑
    """
    
    def simplify_path(path: str) -> list:
        """
        簡化路徑：解析 .. 並返回路徑組件列表
        
        Args:
            path: 原始路徑字串
        
        Returns:
            list: 簡化後的路徑組件列表
        """
        components = path.split('/')
        stack = []
        
        for comp in components:
            if comp == '' or comp == '.':
                # 空字串或當前目錄，跳過
                continue
            elif comp == '..':
                # 父目錄，彈出堆疊（如果非空）
                if stack:
                    stack.pop()
            else:
                # 正常目錄/檔案名，入堆疊
                stack.append(comp)
        
        return stack
    
    def longest_common_suffix(lists: list) -> list:
        """
        找多個列表的最長公共後綴
        
        Args:
            lists: 路徑組件列表的列表
        
        Returns:
            list: 最長公共後綴組件
        """
        if not lists:
            return []
        
        # 反轉所有列表，轉化為求最長公共前綴
        reversed_lists = [lst[::-1] for lst in lists]
        
        # 找最短列表的長度
        min_len = min(len(lst) for lst in reversed_lists)
        
        # 逐位置比較
        common_len = 0
        for i in range(min_len):
            # 取第一個列表的第 i 個元素作為基準
            base = reversed_lists[0][i]
            # 檢查所有列表的第 i 個元素是否相同
            if all(lst[i] == base for lst in reversed_lists):
                common_len += 1
            else:
                break
        
        # 返回公共後綴（反轉回來）
        return reversed_lists[0][:common_len][::-1]
    
    # Step 1: 簡化所有路徑
    simplified = [simplify_path(p) for p in paths]
    
    # Step 2: 找最長公共後綴
    common_suffix = longest_common_suffix(simplified)
    
    # Step 3: 構建結果路徑
    if not common_suffix:
        return ""
    
    return '/' + '/'.join(common_suffix)

🧪 測試用例

# Test 1: 基本範例
paths1 = [
    "/a/folder1/../folder1/a/leaf.txt",
    "/b/folder2/../folder1/a/leaf.txt",
    "/a/folder3/folder1/folder1/../a/leaf.txt"
]
print(solution(paths1))  # Expected: "/folder1/a/leaf.txt"

# Test 2: 完全相同的路徑
paths2 = [
    "/a/b/c/file.txt",
    "/a/b/c/file.txt",
    "/a/b/c/file.txt"
]
print(solution(paths2))  # Expected: "/a/b/c/file.txt"

# Test 3: 無公共後綴
paths3 = [
    "/a/file1.txt",
    "/b/file2.txt",
    "/c/file3.txt"
]
print(solution(paths3))  # Expected: ""

# Test 4: 只有檔案名相同
paths4 = [
    "/a/b/file.txt",
    "/x/y/file.txt",
    "/m/n/file.txt"
]
print(solution(paths4))  # Expected: "/file.txt"

# Test 5: 包含多個 ..
paths5 = [
    "/a/b/c/../d/../e/file.txt",
    "/x/y/../z/e/file.txt"
]
print(solution(paths5))  # Expected: "/e/file.txt"

# Test 6: 單個路徑
paths6 = ["/a/b/c/file.txt"]
print(solution(paths6))  # Expected: "/a/b/c/file.txt"

# Test 7: 根目錄 ..
paths7 = [
    "/../a/b/file.txt",
    "/c/d/file.txt"
]
print(solution(paths7))  # Expected: "/file.txt"

# Test 8: 空陣列
paths8 = []
print(solution(paths8))  # Expected: ""

複雜度分析

項目	複雜度
時間複雜度	O(n × m)，n = 路徑數量，m = 平均路徑長度
空間複雜度	O(n × m)，儲存簡化後的路徑

🤯 面試官的 Followup 陷阱

Followup 1: 如果要返回原始路徑中的公共後綴部分？

問題：不是簡化後的後綴，而是原始字串中對應的部分？

答案：需要維護原始路徑與簡化路徑的映射關係。

def solution_with_original_mapping(paths):
    """返回原始路徑中的公共後綴"""
    # 記錄每個簡化組件對應的原始位置
    # 實現複雜度較高，需要逐字元追蹤
    pass

Followup 2: 如何處理符號連結（symlink）？

問題：如果路徑中有符號連結，.. 的行為可能不同？

答案：需要區分「邏輯路徑」和「物理路徑」。題目通常假設是邏輯路徑處理。

Followup 3: 如果路徑非常長（100萬字元）？

答案：使用串流處理，不一次性載入整個路徑。

def simplify_path_streaming(path_iterator):
    """串流路徑簡化"""
    stack = []
    for char in path_iterator:
        # 逐字元處理
        pass
    return stack

Followup 4: 如何優化空間複雜度？

答案：不儲存完整簡化路徑，直接從末尾開始比較。

def solution_optimized(paths):
    """空間優化版本：邊簡化邊比較"""
    # 從末尾開始，逐組件比較
    # 需要反向遍歷路徑
    pass

🔥 為什麼大多數人會掛？

常見錯誤	正確做法
忘記處理 `..`	用堆疊模擬目錄遍歷
直接比較字串後綴	按 `/` 分割成組件再比較
忘記結果要以 `/` 開頭	拼接時加上前導 `/`
空路徑沒處理	檢查空陣列、空組件列表
`..` 在根目錄的情況	堆疊為空時不彈出

程式碼模板（可直接使用）

def solution(paths: list) -> str:
    def simplify(path):
        stack = []
        for comp in path.split('/'):
            if comp == '..':
                if stack: stack.pop()
            elif comp and comp != '.':
                stack.append(comp)
        return stack
    
    if not paths:
        return ""
    
    simplified = [simplify(p) for p in paths]
    
    # 反轉找 LCP
    rev = [s[::-1] for s in simplified]
    min_len = min(len(r) for r in rev)
    
    common = 0
    for i in range(min_len):
        if all(r[i] == rev[0][i] for r in rev):
            common += 1
        else:
            break
    
    suffix = rev[0][:common][::-1]
    return '/' + '/'.join(suffix) if suffix else ""

📞 oavoservice 服務

備戰 ZipRecruiter 等大廠 New Grad OA 無需焦慮！

oavoservice 專業 OA 代寫服務重磅助力，精準攻克 CodeSignal、HackerRank 等全平台線上評測難題。

針對 ZipRecruiter OA 邏輯為王、注重細節的核心特點，我們提供：

✅ OA代寫：CodeSignal 滿分保障，100% 通過全部測試用例
✅ VO輔助：Technical Screen 即時場外助攻
✅ 一對一精準對接：資深工程師團隊，深耕陣列處理、雙指標、路徑處理等高頻題型
✅ 遠程無痕操作：嚴格保障個人資訊與操作安全

所有訂單承諾 100% 通過全部測試用例，未達標全額退款！

無論你是時間緊張無暇備考，還是對邊界處理、分類邏輯把握不準，我們都能高效完成 ZipRecruiter OA 等各類評測任務，幫你輕鬆打通求職第一關，順利銜接後續 Recruiter Call 與技術面。

👉 立即添加微信：Coding0201

不要讓一道路徑處理題，毀掉你的 ZipRecruiter Offer。

本文由 oavoservice 團隊原創，轉載請註明出處。