✅ 字节跳动春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：90分钟/套）
• 对照解析查漏补缺
• 配套练习题库

互联网必备刷题宝典🔗

📢 字节跳动技术岗笔试重要信息速览

⏰ 笔试时间安排

• 常规场次：每周六交替进行
  • 上午场 10:00~12:00
  • 晚间场 19:00~21:00
• 通知时间：提前2天通过邮箱发送考试链接

🧩 笔试题型分布

⚙️ 考试设置要点

• 考试平台：牛客网（ACM模式）
• 监考要求：
  • 必须开启笔记本前置摄像头
  • 禁止使用手机（需小程序锁定）
  • 允许使用本地IDE
• 编程规范：
  • 严格遵循输入输出格式
  • 注意时间复杂度控制（通常1s对应1e8次运算）

📚 笔试经验贴

（所有展示题面均已进行改编处理，保留核心考点）

本题库收录整理自：

1. 互联网公开的笔试真题回忆版（经网友投稿）
2. 各大技术社区公开讨论的经典题型
3. 历年校招考生提供的解题思路

🔍 题库特点：

• 100%真实笔试场景还原
• 包含高频考点题型
• 提供多语言实现参考
• 持续更新2024届最新真题

⚠️ 注意事项：

1. 所有题目均来自公开渠道，已进行改编脱敏处理
2. 实际笔试可能出现题型变化，请以官方通知为准

🚀 春招备战指南

金三银四求职季即将到来！这里整理了最新字节跳动真题及解析，助你快速掌握笔试套路。建议重点突破以下题型：

1. 动态规划/状态压缩
2. 树形结构应用
3. 字符串模式匹配
4. 滑动窗口/双指针

（👇 下附最新笔试真题及详细解析 👇）

题目 1：数组染色问题

题目内容

小基有一个长度为 的数组，他想要选择一个下标 ，随后，将 及其左边元素全部染红， 右边的元素全部染蓝，使得红色元素的极差和蓝色元素的极差的差的绝对值最小，请你直接输出这个值。

注：极差是指数组中最大值和最小值的差。

输入描述

第一行输入一个整数 代表数组的长度。

第二行 个整数 代表数组的元素。

输出描述

在一行上输出一个正整数，表示红色元素的极差和蓝色元素的极差的差的绝对值的最小值。

样例1

输入

5
1 2 4 3 5

输出

1

说明 红色元素为 ，极差为 ；蓝色元素为 ，极差为 ，差的绝对值为 。

题解

这道题目的核心在于如何高效地计算每个可能的分割点对应的极差差值。

关键思路是使用前缀最值来优化计算。对于每个位置 ，需要知道：

1. 左侧（包含 ）的最大值和最小值
2. 右侧的最大值和最小值

通过预处理这些信息，可以在 时间内得到任意分割点的答案。

时间复杂度：，其中 是数组长度。这个复杂度对于给定的数据范围（）是完全可以接受的。

代码实现

C++

int solve_array_coloring(vector<int>& nums) {
    int len = nums.size();
    vector<int> left_max(len), left_min(len);
    vector<int> right_max(len), right_min(len);
    
    // 预处理左侧最值
    left_max[0] = left_min[0] = nums[0];
    for(int i = 1; i < len; i++) {
        left_max[i] = max(left_max[i-1], nums[i]);
        left_min[i] = min(left_min[i-1], nums[i]);
    }
    
    // 预处理右侧最值
    right_max[len-1] = right_min[len-1] = nums[len-1];
    for(int i = len-2; i >= 0; i--) {
        right_max[i] = max(right_max[i+1], nums[i]);
        right_min[i] = min(right_min[i+1], nums[i]);
    }
    
    int result = INT_MAX;
    for(int i = 0; i < len-1; i++) {
        int left_diff = left_max[i] - left_min[i];
        int right_diff = right_max[i+1] - right_min[i+1];
        result = min(result, abs(left_diff - right_diff));
    }
    
    return result;
}

Python

def solve_array_coloring(nums):
    n = len(nums)
    left_max = [0] * n
    left_min = [0] * n
    right_max = [0] * n
    right_min = [0] * n
    
    # 预处理左侧最值
    left_max[0] = left_min[0] = nums[0]
    for i in range(1, n):
        left_max[i] = max(left_max[i-1], nums[i])
        left_min[i] = min(left_min[i-1], nums[i])
    
    # 预处理右侧最值
    right_max[-1] = right_min[-1] = nums[-1]
    for i in range(n-2, -1, -1):
        right_max[i] = max(right_max[i+1], nums[i])
        right_min[i] = min(right_min[i+1], nums[i])
    
    result = float('inf')
    for i in range(n-1):
        left_diff = left_max[i] - left_min[i]
        right_diff = right_max[i+1] - right_min[i+1]
        result = min(result, abs(left_diff - right_diff))
    
    return result

Java

public class Solution {
    public int solveArrayColoring(int[] nums) {
        int len = nums.length;
        int[] leftMax = new int[len];
        int[] leftMin = new int[len];
        int[] rightMax = new int[len];
        int[] rightMin = new int[len];
        
        // 预处理左侧最值
        leftMax[0] = leftMin[0] = nums[0];
        for(int i = 1; i < len; i++) {
            leftMax[i] = Math.max(leftMax[i-1], nums[i]);
            leftMin[i] = Math.min(leftMin[i-1], nums[i]);
        }
        
        // 预处理右侧最值
        rightMax[len-1] = rightMin[len-1] = nums[len-1];
        for(int i = len-2; i >= 0; i--) {
            rightMax[i] = Math.max(rightMax[i+1], nums[i]);
            rightMin[i] = Math.min(rightMin[i+1], nums[i]);
        }
        
        int result = Integer.MAX_VALUE;
        for(int i = 0; i < len-1; i++) {
            int leftDiff = leftMax[i] - leftMin[i];
            int rightDiff = rightMax[i+1] - rightMin[i+1];
            result = Math.min(result, Math.abs(leftDiff - rightDiff));
        }
        
        return result;
    }
}

题目 2：排列对数问题

题目内容

小基有一个长度为 的排列 ，他想知道 中有多少个 对满足： 且 。

输入描述

输入包含两行。

第一行一个正整数 ，表示排列的长度。

第二行 个正整数 ，表示排列 （保证输入是一个排列）。

输出描述

输出一行一个整数表示满足条件的对数个数。

样例1

输入

5
2 1 3 5 4

输出

4

说明 以下四对满足条件：

题解

这道题目的关键是发现等式 可以转化为 。

利用这个性质，可以使用哈希表来记录每个位置的 值的出现次数。对于每个新的位置，只需要查找之前是否出现过对应的值。

时间复杂度：，空间复杂度：。对于给定的数据范围（）是完全可以接受的。

代码实现

C++

long long count_pairs(vector<int>& perm) {
    int n = perm.size();
    unordered_map<int, int> diff_cnt;
    long long ans = 0;
    
    for(int i = 0; i < n; i++) {
        int curr_diff = perm[i] - i - 1;
        ans += diff_cnt[curr_diff];
        diff_cnt[curr_diff]++;
    }
    
    return ans;
}

Python

def count_pairs(perm):
    n = len(perm)
    diff_cnt = {}
    ans = 0
    
    for i in range(n):
        curr_diff = perm[i] - i - 1
        ans += diff_cnt.get(curr_diff, 0)