HackerRank OA 常见题型全解析（2026 更新）：5 大必考题型与解题模板

HackerRank 是北美科技公司最常用的在线评估平台之一。Meta、Uber、Netflix、Pinterest、Shopify 等大厂都用它来做 OA。

跟 CodeSignal 不同，HackerRank 的 OA 通常是自定义题目，难度覆盖 Easy 到 Hard，更侧重考察实际编码能力而非刷题经验。

HackerRank OA 常见结构

• 1-2 道编程题：30-60 分钟
• 语言自由：支持 Python、Java、C++、JavaScript 等
• 在线 IDE：可以直接运行和调试
• 隐藏测试用例：提交后看通过率

---

题型一：字符串处理与模式匹配

典型题目

题目：给定一个文本字符串和一个模式字符串，找出所有匹配的位置。

def find_all_patterns(text: str, pattern: str) -> list[int]:
    """Rabin-Karp 算法找所有匹配位置"""
    if not pattern or not text or len(pattern) > len(text):
        return []
    
    n, m = len(text), len(pattern)
    BASE = 26
    MOD = 10**9 + 7
    
    # 计算 pattern 的 hash
    pattern_hash = 0
    text_hash = 0
    power = pow(BASE, m - 1, MOD)
    
    for i in range(m):
        pattern_hash = (pattern_hash * BASE + ord(pattern[i])) % MOD
        text_hash = (text_hash * BASE + ord(text[i])) % MOD
    
    results = []
    for i in range(n - m + 1):
        if text_hash == pattern_hash:
            # 验证（处理 hash collision）
            if text[i:i+m] == pattern:
                results.append(i)
        
        if i < n - m:
            text_hash = ((text_hash - ord(text[i]) * power) * BASE + ord(text[i + m])) % MOD
    
    return results

关键技巧：

• 暴力解法 O(N*M)，Rabin-Karp 平均 O(N+M)
• 注意 hash collision 处理
• 边界条件：空字符串、模式比文本长

---

题型二：动态规划

典型题目

题目：最长递增子序列（LIS）的变种——给定数组，求最长 wiggle subsequence 的长度。

def wiggle_subsequence(nums: list[int]) -> int:
    if len(nums) < 2:
        return len(nums)
    
    # up[i] 表示以第 i 个元素结尾，最后一步是上升的 wiggle 长度
    # down[i] 表示以第第 i 个元素结尾，最后一步是下降的 wiggle 长度
    up = 1
    down = 1
    
    for i in range(1, len(nums)):
        if nums[i] > nums[i - 1]:
            up = down + 1
        elif nums[i] < nums[i - 1]:
            down = up + 1
        # 相等则不更新
    
    return max(up, down)

动态规划通用框架：

def dp_template(nums):
    n = len(nums)
    dp = [0] * n
    
    # 1. 定义状态
    # dp[i] = 以第 i 个元素结尾的 xxx
    
    # 2. 初始化
    dp[0] = 1  # base case
    
    # 3. 状态转移
    for i in range(1, n):
        for j in range(i):
            if condition(nums[i], nums[j]):
                dp[i] = max(dp[i], dp[j] + 1)
    
    # 4. 返回答案
    return max(dp)

---

题型三：图论与搜索

典型题目

题目：岛屿数量 + 连通分量统计

from collections import deque

def num_islands(grid: list[list[str]]) -> int:
    if not grid:
        return 0
    
    rows, cols = len(grid), len(grid[0])
    count = 0
    
    def bfs(r, c):
        queue = deque([(r, c)])
        grid[r][c] = '0'  # 标记为已访问
        
        while queue:
            row, col = queue.popleft()
            for dr, dc in [(0,1), (0,-1), (1,0), (-1,0)]:
                nr, nc = row + dr, col + dc
                if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == '1':
                    grid[nr][nc] = '0'
                    queue.append((nr, nc))
    
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] == '1':
                bfs(i, j)
                count += 1
    
    return count

图论常见模板：

题型	算法	时间复杂度
最短路径（无权）	BFS	O(V+E)
最短路径（有权）	Dijkstra	O(E log V)
拓扑排序	Kahn’s / DFS	O(V+E)
连通分量	Union-Find / BFS	O(V+E)
最小生成树	Kruskal / Prim	O(E log V)

---

题型四：滑动窗口与双指针

典型题目

题目：给定一个整数数组和值 k，找出数组中至少包含 k 个偶数的最短子数组长度。

def shortest_subarray_with_k_evens(nums: list[int], k: int) -> int:
    if k == 0:
        return 0
    
    left = 0
    even_count = 0
    result = float('inf')
    
    for right in range(len(nums)):
        if nums[right] % 2 == 0:
            even_count += 1
        
        while even_count >= k:
            result = min(result, right - left + 1)
            if nums[left] % 2 == 0:
                even_count -= 1
            left += 1
    
    return result if result != float('inf') else -1

滑动窗口框架：

def sliding_window_template(s, target):
    left = 0
    window = {}
    result = float('inf')
    
    for right in range(len(s)):
        # 1. 添加 right 元素到窗口
        add_to_window(s[right], window)
        
        # 2. 满足条件时收缩窗口
        while is_valid(window, target):
            result = update_result(result, left, right)
            # 移除 left 元素
            remove_from_window(s[left], window)
            left += 1
    
    return result

---

题型五：排序与哈希

典型题目

题目：数组中两数之和等于目标值的所有不重复组合。

from collections import Counter

def two_sum_all_pairs(nums: list[int], target: int) -> list[list[int]]:
    count = Counter(nums)
    result = set()
    
    for num in count:
        complement = target - num
        if complement in count:
            if num != complement:
                result.add((min(num, complement), max(num, complement)))
            elif count[num] >= 2:
                result.add((num, num))
    
    return [list(pair) for pair in sorted(result)]

---

实战技巧

1. 先跑通样例再优化

HackerRank 允许你在提交前运行自定义测试用例，确保基础逻辑正确再考虑边界情况和性能优化。

2. 善用内置库

# 排序
sorted_list = sorted(arr, key=lambda x: (x[1], -x[0]))

# Counter 统计频率
from collections import Counter
freq = Counter(nums)

# deque 做双端队列
from collections import deque
dq = deque()
dq.appendleft(x)

# heap 做优先队列
import heapq
heapq.heappush(heap, (priority, value))

3. 时间复杂度意识

数据规模	允许的复杂度
N ≤ 10^3	O(N²)
N ≤ 10^5	O(N log N)
N ≤ 10^7	O(N)

---

FAQ

HackerRank 和 CodeSignal 有什么区别？

HackerRank 通常是自定义题目，CodeSignal 有标准题库。HackerRank 更灵活，CodeSignal 更标准化。

可以用 IDE 提示吗？

HackerRank 的在线 IDE 有基础自动补全，但不支持外部 IDE。

通过率多少算过？

没有统一标准，但通常要求 70%+ 的测试用例通过，且时间复杂度在限制内。

---

💡 需要面试辅导？

如果你对准备技术面试感到迷茫，或者想要个性化的面试指导和简历优化，欢迎联系 Interview Coach Pro 获取一对一辅导服务。

👉 联系我们 获取专属面试准备方案