字节笔试题(含答案)
Posted 程序dunk
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了字节笔试题(含答案)相关的知识,希望对你有一定的参考价值。
个人博客欢迎访问
总结不易,如果对你有帮助,请点赞关注支持一下
微信搜索程序dunk,关注公众号,获取博主的数据结构与算法的代码笔记
目录
2019春招研发部分编程题
试题链接:字节跳动2019春招研发部分编程题汇总
万万没想到之聪明的编辑(AC)
我叫王大锤,是一家出版社的编辑。我负责校对投稿来的英文稿件,这份工作非常烦人,因为每天都要去修正无数的拼写错误。但是,优秀的人总能在平凡的工作中发现真理。我发现一个发现拼写错误的捷径:
\\1. 三个同样的字母连在一起,一定是拼写错误,去掉一个的就好啦:比如 helllo -> hello
\\2. 两对一样的字母(AABB型)连在一起,一定是拼写错误,去掉第二对的一个字母就好啦:比如 helloo -> hello
\\3. 上面的规则优先“从左到右”匹配,即如果是AABBCC,虽然AABB和BBCC都是错误拼写,应该优先考虑修复AABB,结果为AABCC
我特喵是个天才!我在蓝翔学过挖掘机和程序设计,按照这个原理写了一个自动校对器,工作效率从此起飞。用不了多久,我就会出任CEO,当上董事长,迎娶白富美,走上人生巅峰,想想都有点小激动呢!
……
万万没想到,我被开除了,临走时老板对我说: “做人做事要兢兢业业、勤勤恳恳、本本分分,人要是行,干一行行一行。一行行行行行;要是不行,干一行不行一行,一行不行行行不行。” 我现在整个人红红火火恍恍惚惚的……
请听题:请实现大锤的自动校对程序
输出描述:
N行,每行包括一个被修复后的字符串。
输入例子1:
2
helloo
wooooooow
输出例子1:
woow
思路
一开始没有想出来,最后拆分问题,将一道题拆为两道题来做,先过滤掉AAA问题,再处理AABBCC问题O(n)
代码
import java.util.*;
public class Main
public static void main(String[] args)
Scanner in = new Scanner(System.in);
int N = in.nextInt();
for(int i = 0; i < N; i++)
String str = in.next();
String res = handler(str);
System.out.println(res);
//先处理三个的情况,在处理AABBCC的情况
private static String handler(String str)
StringBuilder builder = new StringBuilder();
char[] chars = str.toCharArray();
char pre = ' ';
int count = 1;
for(char ch : chars)
if (ch == pre)
count++;
continue;
else
if (count >= 2)
builder.append(pre);
count = 1;
pre = ch;
builder.append(ch);
if (count >= 2)
builder.append(pre);
chars = builder.toString().toCharArray();
builder = new StringBuilder();
boolean flag = false;
int n = chars.length;
for (int i = 0; i < n; i++)
builder.append(chars[i]);
if (i + 1 < n && chars[i] == chars[i + 1])
if (flag)
flag = false;
else
flag = true;
builder.append(chars[i]);
i++;
else
flag = false;
return builder.toString();
万万没想到之抓捕孔连顺(AC)
我叫王大锤,是一名特工。我刚刚接到任务:在字节跳动大街进行埋伏,抓捕恐怖分子孔连顺。和我一起行动的还有另外两名特工,我提议
\\1. 我们在字节跳动大街的N个建筑中选定3个埋伏地点。
\\2. 为了相互照应,我们决定相距最远的两名特工间的距离不超过D。
我特喵是个天才! 经过精密的计算,我们从X种可行的埋伏方案中选择了一种。这个方案万无一失,颤抖吧,孔连顺!
……
万万没想到,计划还是失败了,孔连顺化妆成小龙女,混在cosplay的队伍中逃出了字节跳动大街。只怪他的伪装太成功了,就是杨过本人来了也发现不了的!
请听题:给定N(可选作为埋伏点的建筑物数)、D(相距最远的两名特工间的距离的最大值)以及可选建筑的坐标,计算在这次行动中,大锤的小队有多少种埋伏选择。
注意:
\\1. 两个特工不能埋伏在同一地点
\\2. 三个特工是等价的:即同样的位置组合(A, B, C) 只算一种埋伏方法,不能因“特工之间互换位置”而重复使用
输入描述:
第一行包含空格分隔的两个数字 N和D(1 ≤ N ≤ 1000000; 1 ≤ D ≤ 1000000)
第二行包含N个建筑物的的位置,每个位置用一个整数(取值区间为[0, 1000000])表示,从小到大排列(将字节跳动大街看做一条数轴)
输出描述:
一个数字,表示不同埋伏方案的数量。结果可能溢出,请对 99997867 取模
输入例子1:
4 3
1 2 3 4
输出例子1:
4
思路
数学题:只要right - left <= D 那么它能够组成的站位就是right - left - 1加到1(等差数列求和),遍历left,为了优化时间,没有采用遍历,通过二分查找直接找到left + D的最小值
注意
注意:一定要用long,亲测,使用int 只能过80%
代码
方法一
import java.util.*;
public class Main
public static void main(String[] args)
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int D = in.nextInt();
int[] locations = new int[N];
for(int i = 0; i < N ; i++)
locations[i] = in.nextInt();
Arrays.sort(locations);
long count = 0;
for (int i = 0; i < N - 2; i++)
int j = binarySearch(locations, locations[i] + D);
if (j - i < 2) break;
//System.out.println(locations[i] + " " + j);
//注意:这里一定要用long,否则结果不正确
long sum = j - i - 1;
count += (1 + sum) * sum / 2;
System.out.println(count %= 99997867);
private static int binarySearch(int[] locations, int t)
int l = 0;
int r = locations.length;
int mid;
while(l < r)
mid = l + r >> 1;
if(locations[mid] >= t)
r = mid;
else
l = mid + 1;
l = l >= locations.length ? locations.length - 1 : l;
return locations[l] > t ? l - 1 : l;
方法二
import java.util.*;
public class Main
private int mod = 99997867;
private void sln()
Scanner sc = new Scanner(System.in);
int N = sc.nextInt(), D = sc.nextInt();
long cnt = 0;
if (N <= 2)
System.out.println(-1);
return;
int[] locs = new int[N];
for (int i = 0; i < N; i++)
locs[i] = sc.nextInt();
sc.close();
int left = 0, right = 2;
while (right < N)
if (locs[right] - locs[left] > D) left++;
else if (right - left < 2) right++;
else
cnt += calC(right - left);
right++;
cnt %= mod;
System.out.println(cnt);
private long calC(long num)
return num * (num - 1) / 2;
public static void main(String[] args)
new Main().sln();
雀魂启动!(AC)
小包最近迷上了一款叫做雀魂的麻将游戏,但是这个游戏规则太复杂,小包玩了几个月了还是输多赢少。
于是生气的小包根据游戏简化了一下规则发明了一种新的麻将,只留下一种花色,并且去除了一些特殊和牌方式(例如七对子等),具体的规则如下:
- 总共有36张牌,每张牌是1~9。每个数字4张牌。
- 你手里有其中的14张牌,如果这14张牌满足如下条件,即算作和牌
- 14张牌中有2张相同数字的牌,称为雀头。
- 除去上述2张牌,剩下12张牌可以组成4个顺子或刻子。顺子的意思是递增的连续3个数字牌(例如234,567等),刻子的意思是相同数字的3个数字牌(例如111,777)
例如:
1 1 1 2 2 2 6 6 6 7 7 7 9 9 可以组成1,2,6,7的4个刻子和9的雀头,可以和牌
1 1 1 1 2 2 3 3 5 6 7 7 8 9 用1做雀头,组123,123,567,789的四个顺子,可以和牌
1 1 1 2 2 2 3 3 3 5 6 7 7 9 无论用1 2 3 7哪个做雀头,都无法组成和牌的条件。
现在,小包从36张牌中抽取了13张牌,他想知道在剩下的23张牌中,再取一张牌,取到哪几种数字牌可以和牌。
输入描述:
输入只有一行,包含13个数字,用空格分隔,每个数字在1~9之间,数据保证同种数字最多出现4次。
输出描述:
输出同样是一行,包含1个或以上的数字。代表他再取到哪些牌可以和牌。若满足条件的有多种牌,请按从小到大的顺序输出。若没有满足条件的牌,请输出一个数字0
输入例子1:
1 1 1 2 2 2 5 5 5 6 6 6 9
输出例子1:
9
例子说明1:
可以组成1,2,6,7的4个刻子和9的雀头
输入例子2:
1 1 1 1 2 2 3 3 5 6 7 8 9
输出例子2:
4 7
例子说明2:
用1做雀头,组123,123,567或456,789的四个顺子
思路
本题考查的是回溯法,由于数据的规模非常小(n<=9),所以递归不会很深。
思路: 已有13张牌,我们从剩余的牌中依次从1到9选择一张牌作为第14张牌,然后判断是否已经构成胡牌。
判断胡牌思路:从1到9中选择一个数字作为雀头,然后判断剩余的数字是否包含4个三张牌
代码
import java.util.*;
public class Main
private static int[]arr = new int[13];
private static int[] count;
public static void main(String[] args)
Scanner scanner = new Scanner(System.in);
count = new int[9];
for (int i = 0; i < arr.length; i++)
arr[i] = scanner.nextInt();
++count[arr[i]-1];
int winCount = 0;
// 选择1到9中的一个作为第14张牌,然后判断是否胡牌
for (int i = 1 ; i <= 9; i++)
if(count[i-1]<4)
++count[i-1];
if(win())
++winCount;
System.out.print(i + " ");
--count[i-1];
if(winCount==0)
System.out.println(0);
public static boolean win()
// 从1到9 中选择一个作为雀头, 然后判断剩余的牌是否构成4对
for (int i = 1; i <= 9; i++)
if (count[i - 1] < 2)
continue;
count[i - 1] -= 2;
if (hasTriples(4))
count[i - 1] += 2;
return true;
count[i - 1] += 2;
return false;
public static boolean hasTriples(int n)
if (n == 0) return true;
// 1到9,每一张牌尝试三张或顺子
for (int i = 1; i <= 9; i++)
if (count[i - 1] >= 3)
count[i - 1] -= 3;
boolean subHasTriples = hasTriples(n - 1);
count[i - 1] += 3;
if (subHasTriples) return true;
if (i <= 7 && count[i - 1] > 0 && count[i] > 0 && count[i + 1] > 0)
--count[i - 1];
--count[i];
--count[i + 1];
boolean subHasTriples = hasTriples(n - 1);
++count[i - 1];
++count[i];
++count[i + 1];
if (subHasTriples)
return true;
return false;
特征提取(AC)
小明是一名算法工程师,同时也是一名铲屎官。某天,他突发奇想,想从猫咪的视频里挖掘一些猫咪的运动信息。为了提取运动信息,他需要从视频的每一帧提取“猫咪特征”。一个猫咪特征是一个两维的vector<x, y>。如果x_1=x_2 and y_1=y_2,那么这俩是同一个特征。
因此,如果喵咪特征连续一致,可以认为喵咪在运动。也就是说,如果特征<a, b>在持续帧里出现,那么它将构成特征运动。比如,特征<a, b>在第2/3/4/7/8帧出现,那么该特征将形成两个特征运动2-3-4 和7-8。
现在,给定每一帧的特征,特征的数量可能不一样。小明期望能找到最长的特征运动。
输入描述:
第一行包含一个正整数N,代表测试用例的个数。
每个测试用例的第一行包含一个正整数M,代表视频的帧数。
接下来的M行,每行代表一帧。其中,第一个数字是该帧的特征个数,接下来的数字是在特征的取值;比如样例输入第三行里,2代表该帧有两个猫咪特征,<1,1>和<2,2>
所有用例的输入特征总数和<100000
N满足1≤N≤100000,M满足1≤M≤10000,一帧的特征个数满足 ≤ 10000。
特征取值均为非负整数。
输出描述:
对每一个测试用例,输出特征运动的长度作为一行
输入例子1:
1
8
2 1 1 2 2
2 1 1 1 4
2 1 1 2 2
2 2 2 1 4
0
0
1 1 1
1 1 1
输出例子1:
3
思路
哈希表存储前一个的特征数组,对比当前特征,相同的,数量 + 1,不同的删除前一个哈希表的特征数组,保留当前哈希表
代码
import java.util.*;
public class Main
public static void main(String[] args)
Scanner in = new Scanner(System.in);
int maxLen = 1;
int N = in.nextInt();
while (N > 0)
int M = in.nextInt();
Map<int[], Integer> preMap = new HashMap<>();
while(M > 0)
int F = in.nextInt();
Map<int[], Integer> curMap = new HashMap<>();
for(int i = 0; i < F; i++)
int[] nums = new int[2];
nums[0] = in.nextInt();
nums[1] = in.nextInt();
curMap.put(nums, 1);
for(int[] keys : preMap.keySet以上是关于字节笔试题(含答案)的主要内容,如果未能解决你的问题,请参考以下文章