【笔试刷题】字节-2026.03.21-改编真题
✅ 春招备战指南 ✅
💡 学习建议：
- 先尝试独立解题
- 对照解析查漏补缺
🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。
🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力
🌸 目前本专栏已经上线200+套真题改编解析，后续会持续更新的
春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗
字节-2026.03.21
1. 小基的片段指纹
问题描述
小基 在整理一批字符串片段时，给每个片段定义了一种“指纹”。
对于长度为 的字符串
和整数
，定义字符串
为下面三部分依次拼接后的结果：
的前
个字符，按字典序从小到大排序；
- 整个字符串
- 去掉前
现在给定一个长度为 的字符串
和一个整数
。请你取出
的所有长度为
的子串，并令
，把每个子串都转成对应的指纹。问最终会得到多少个不同的指纹字符串。
这里的子串指从原字符串中连续选取的一段字符。
输入格式
第一行输入一个整数 ，表示数据组数。
对于每组数据：
- 第一行输入两个整数
，分别表示字符串长度和询问长度；
- 第二行输入一个长度为
、由大小写字母混合构成的字符串
。
输出格式
对于每组数据，输出一行一个整数，表示不同指纹字符串的数量。
样例输入
2
5 4
bAbbb
7 3
nuhhhhh
样例输出
1
3
数据范围
题解
每个长度为 的子串都会独立生成一个新字符串，题面没有要求做复杂优化，直接按定义模拟即可。
设当前子串为 ，令
：
- 第一段是
排序后的结果；
- 第二段是整个
- 第三段是
排序后的结果。
把三段拼起来就是这个子串的指纹。把所有指纹放进集合去重，最后集合大小就是答案。
由于 ，总复杂度是
，完全足够。
- Python
import sys
input = lambda: sys.stdin.readline().strip()
def solve():
t = int(input())
ans = []
for _ in range(t):
n, x = map(int, input().split())
s = input()
k = x // 2
seen = set()
for i in range(n - x + 1):
sub = s[i:i + x]
part1 = ''.join(sorted(sub[:k]))
part2 = ''.join(sorted(sub, reverse=True))
part3 = ''.join(sorted(sub[k:]))
seen.add(part1 + part2 + part3)
ans.append(str(len(seen)))
print('\n'.join(ans))
if __name__ == "__main__":
solve()
- Cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n, x;
cin >> n >> x;
string s;
cin >> s;
int k = x / 2;
unordered_set<string> seen;
seen.reserve(n + 5);
for (int i = 0; i + x <= n; ++i) {
string sub = s.substr(i, x);
string part1 = sub.substr(0, k);
sort(part1.begin(), part1.end());
string part2 = sub;
sort(part2.begin(), part2.end(), greater<char>());
string part3 = sub.substr(k);
sort(part3.begin(), part3.end());
seen.insert(part1 + part2 + part3);
}
cout << seen.size() << "\n";
}
return 0;
}
- Java
import java.io.*;
import java.util.*;
public class Main {
private static String sortAsc(String s) {
char[] arr = s.toCharArray();
Arrays.sort(arr);
return new String(arr);
}
private static String sortDesc(String s) {
char[] arr = s.toCharArray();
Arrays.sort(arr);
StringBuilder sb = new StringBuilder(arr.length);
for (int i = arr.length - 1; i >= 0; --i) {
sb.append(arr[i]);
}
return sb.toString();
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine().trim());
StringBuilder out = new StringBuilder();
while (T-- > 0) {
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
int x = Integer.parseInt(st.nextToken());
String s = br.readLine().trim();
int k = x / 2;
HashSet<String> seen = new HashSet<>();
for (int i = 0; i + x <= n; ++i) {
String sub = s.substring(i, i + x);
String part1 = sortAsc(sub.substring(0, k));
String part2 = sortDesc(sub);
String part3 = sortAsc(sub.substring(k));
seen.add(part1 + part2 + part3);
}
out.append(seen.size()).append('\n');
}
System.out.print(out);
}
}
2. 小柯的单词夹层
问题描述
小柯正在研究固定长度单词的字典序区间。
对于两个长度相同的字符串，字典序比较按照从左到右逐个字符比较的规则进行。例如 ac < ad，bc > ad。
现在假设每个由小写字母构成、长度为 的字符串都可以看成一个合法单词。给定两个长度都为
的单词
和
，请你计算：有多少个长度为
的单词，其字典序严格大于
，并且严格小于
。
如果 的字典序不小于
，则答案为
。
输入格式
第一行输入一个整数 ，表示数据组数。
接下来 行，每行输入：
- 一个整数
- 两个仅由小写字母组成的字符串
。
输出格式
输出 行，每行一个整数，表示对应测试数据的答案。
样例输入
4
1 z a
1 a z
2 az bb
3 bbb bbb
样例输出
0
24
1
0
数据范围
- 对于
的数据，
题解
长度固定时，字典序比较和高位优先的进制数比较完全一致。
把一个长度为 的小写字符串看成一个
进制数：
'a'对应'b'对应- ...
'z'对应
那么字符串 对应的值就是：
于是问题就转成了：求开区间 里有多少个整数。
- 如果
，答案是
；
- 否则答案就是
。
因为 ，最大值不会超过
，使用
long long 足够。
- Python
import sys
input = lambda: sys.stdin.readline().strip()
def value_of(word: str) -> int:
value = 0
for ch in word:
value = value * 26 + (ord(ch) - ord('a'))
return value
def solve():
t = int(input())
ans = []
for _ in range(t):
n, a, b = input().split()
if a >= b:
ans.append("0")
continue
va = value_of(a)
vb = value_of(b)
ans.append(str(vb - va - 1))
print('\n'.join(ans))
if __name__ == "__main__":
solve()
- Cpp
#include <bits/stdc++.h>
using namespace std;
long long valueOf(const string& s) {
long long value = 0;
for (char ch : s) {
value = value * 26 + (ch - 'a');
}
return value;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n;
string A, B;
cin >> n >> A >> B;
if (A >= B) {
cout << 0 << "\n";
continue;
}
long long valA = valueOf(A);
long long valB = valueOf(B);
cout << valB - valA - 1 << "\n";
}
return 0;
}
- Java
import java.io.*;
import java.util.*;
public class Main {
private static long valueOf(String s) {
long value = 0;
for (int i = 0; i < s.length(); ++i) {
value = value * 26 + (s.charAt(i) - 'a');
}
return value;
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine().trim());
StringBuilder out = new StringBuilder();
while (T-- > 0) {
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
String A = st.nextToken();
String B = st.nextToken();
if (A.compareTo(B) >= 0) {
out.append(0).append('\n');
continue;
}
long valA = valueOf(A);
long valB = valueOf(B);
out.append(valB - valA - 1).append('\n');
}
System.out.print(out);
}
}
3. 小毛的十字刷漆
问题描述
小毛拿到了一块 的字母方阵，每个格子里都写着一个大小写字母。
现在他准备选择一整行和一整列，把这两者并集中的所有格子都重新刷成同一个字母。由于行列交点会被同时选中，所以实际被覆盖的格子数始终是 。
他想知道，怎样选择行、列以及最终刷成的字母，才能让整个方阵中出现次数最多的某个字母尽可能多。你需要同时输出：
- 这个最大出现次数；
- 达到该最大值的不同方案数。
如果两个方案中，所选的行不同、列不同，或者刷成的字母不同，就认为它们是不同方案。题目区分大小写。
输入格式
第一行输入一个整数 ，表示数据组数。
对于每组数据：
- 第一行输入一个整数
- 接下来输入
行是一个长度为
。
输出格式
对于每组数据，输出一行两个整数，分别表示最大出现次数和最优方案数。
样例输入
3
1
a
3
aaa
aDC
CCC
6
abcDef
AbcdeF
abcdef
AbcdeF
aBcdef
abcDEF
样例输出
1 52
8 4
16 40
数据范围
题解
固定最终刷成的字母为 ch，再固定选择第 r 行和第 c 列。
这次操作总共会覆盖 个格子。但其中有一部分格子原本就已经是
ch，它们不会增加新的 ch 数量。设：
tot[ch]：整个矩阵中ch的总数；row[ch][r]：第r行中ch的个数；col[ch][c]：第c列中ch的个数。
那么被覆盖区域中原本就是 ch 的格子数为：
所以操作后，字母 ch 的总数会变成：
也就是说，对固定的 ch，问题变成了：
- 枚举所有
(r,c)； - 让上式里的“损失值”最小；
- 统计达到最小值的方案个数。
字母只有
剩余60%内容，订阅专栏后可继续查看/也可单篇购买
互联网刷题笔试宝典，这里涵盖了市面上大部分的笔试题合集，希望助大家春秋招一臂之力
