CodeSignal OA 常见题型全解析（2026 更新）：TikTok、Snap、Pinterest 都在考

CodeSignal 是北美科技公司广泛使用的在线评估平台。跟 HackerRank 不同，CodeSignal 有标准化题库和能力评估模式。

TikTok、Snap、Pinterest、Atlassian、Instacart 等公司都用 CodeSignal 做 OA 或技术初筛。

CodeSignal OA 常见形式

模式一：CodeSignal Aptitude Test

40 分钟 25 道题
从简单到困难，难度递增
覆盖基础编程、语法、简单算法
不需要提交代码，主要是选择题

模式二：Custom Assessment

1-2 道编程题，30-60 分钟
公司自定义题目
需要写完整代码并运行通过测试用例
更像 LeetCode 模式

模式三：Verified Score

摄像头监考
40 分钟完成 25 题
有效期 1 年，多家认可

题型一：基础数组操作

典型题目：数组旋转

题目：将数组向右旋转 k 步。

def rotate_array(nums: list[int], k: int) -> None:
    """原地旋转，O(1) 空间"""
    n = len(nums)
    k = k % n  # 处理 k > n 的情况
    
    # 三次翻转法
    def reverse(left: int, right: int):
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1
    
    reverse(0, n - 1)       # 全部翻转
    reverse(0, k - 1)       # 翻转前 k 个
    reverse(k, n - 1)       # 翻转后 n-k 个

关键技巧：

三次翻转法：O(N) 时间，O(1) 空间
不要创建新数组，原地修改
处理 k > n 的边界情况

题型二：动态规划

典型题目：爬楼梯变种

题目：每次可以爬 1、2 或 3 个台阶，问爬到第 n 层有多少种方法。

def climb_stairs_3(n: int) -> int:
    if n <= 0:
        return 0
    if n == 1:
        return 1
    
    # dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
    dp = [0] * (n + 1)
    dp[1] = 1
    dp[2] = 2  # 1+1 或 2
    
    for i in range(3, n + 1):
        dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
    
    return dp[n]

# 空间优化版本
def climb_stairs_3_opt(n: int) -> int:
    if n == 1:
        return 1
    if n == 2:
        return 2
    
    a, b, c = 1, 2, 0
    for _ in range(3, n + 1):
        c = a + b + c
        a, b = b, c
    
    return c

题型三：树与图

典型题目：二叉树最大路径和

题目：给定一个二叉树，返回其最大路径和。

from typing import Optional

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def __init__(self):
        self.max_sum = float('-inf')
    
    def max_path_sum(self, root: Optional[TreeNode]) -> int:
        self._dfs(root)
        return self.max_sum
    
    def _dfs(self, node: Optional[TreeNode]) -> int:
        if not node:
            return 0
        
        # 左右子树的最大贡献（负数则不计）
        left_gain = max(self._dfs(node.left), 0)
        right_gain = max(self._dfs(node.right), 0)
        
        # 以当前节点为"根"的路径和
        current_path = node.val + left_gain + right_gain
        
        # 更新全局最大值
        self.max_sum = max(self.max_sum, current_path)
        
        # 返回给父节点：只能选一边
        return node.val + max(left_gain, right_gain)

关键点：

区分”经过节点的最大路径”和”返回给父节点的最大值”
负数子树贡献直接丢弃（max(…, 0)）
时间复杂度：O(N)，每个节点访问一次

题型四：字符串处理

典型题目：验证回文串

题目：给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

def is_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    
    while left < right:
        # 跳过非字母数字字符
        while left < right and not s[left].isalnum():
            left += 1
        while left < right and not s[right].isalnum():
            right -= 1
        
        # 比较（忽略大小写）
        if s[left].lower() != s[right].lower():
            return False
        
        left += 1
        right -= 1
    
    return True

变种：最多删除一个字符后是否是回文

def valid_palindrome(s: str) -> bool:
    left, right = 0, len(s) - 1
    
    while left < right:
        if s[left] != s[right]:
            # 尝试删除左边或右边字符
            skip_left = s[left+1:right+1]
            skip_right = s[left:right]
            return skip_left == skip_left[::-1] or skip_right == skip_right[::-1]
        left += 1
        right -= 1
    
    return True

题型五：排序与搜索

典型题目：在旋转排序数组中搜索

题目：给定一个旋转后的排序数组和一个目标值，返回目标值的索引。

def search_rotated_array(nums: list[int], target: int) -> int:
    left, right = 0, len(nums) - 1
    
    while left <= right:
        mid = (left + right) // 2
        
        if nums[mid] == target:
            return mid
        
        # 判断哪一半是有序的
        if nums[left] <= nums[mid]:
            # 左半有序
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:
            # 右半有序
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    
    return -1

关键思路：

每次二分后，至少有一半边是有序的
判断目标值是否在有秩序内

题型六：哈希与计数

典型题目：子数组和为 K

题目：给定一个整数数组和一个整数 k，找出数组中和为 k 的连续子数组的个数。

from collections import Counter

def subarray_sum_k(nums: list[int], k: int) -> int:
    count = 0
    current_sum = 0
    # prefix_sum -> frequency
    prefix_counts = Counter({0: 1})
    
    for num in nums:
        current_sum += num
        
        # 如果 current_sum - k 存在，说明有一段子数组和为 k
        count += prefix_counts[current_sum - k]
        
        prefix_counts[current_sum] += 1
    
    return count

核心思想：前缀和 + 哈希表

prefix_sum[j] - prefix_sum[i] = k → 区间 (i, j] 的和为 k
时间复杂度：O(N)

CodeSignal 实战技巧

1. Aptitude Test 速刷策略

前 15 题：基础语法题，直接秒杀（每题不超过 30 秒）
16-20 题：简单逻辑，可能需要画一下（每题 1 分钟）
21-25 题：困难题，如果不确定就跳过
不需要全部做对，重点是前 20 题的高正确率

2. Custom Assessment 注意事项

先写暴力解法确保正确
再看能否优化
充分利用在线 IDE 的测试功能
注意边界条件（空数组、负数、重复元素）

3. 常用代码片段

# 二分查找模板
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# BFS 模板
from collections import deque
def bfs(graph, start):
    visited = {start}
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in graph.get(node, []):
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# DFS 模板
def dfs(graph, node, visited=None):
    if visited is None:
        visited = set()
    visited.add(node)
    for neighbor in graph.get(node, []):
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

FAQ

CodeSignal 和 LeetCode 有什么区别？

CodeSignal 题目更贴近实际工作场景，LeetCode 更偏向算法竞赛。

Verified Score 有效期多久？

1 年。可以在有效期内投递多家公司。

面试中可以用外部资源吗？

Aptitude Test 可以；Custom Assessment 通常不允许。

💡 需要面试辅导？

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