字节跳动2020届秋招笔试题

最新推荐文章于 2024-04-16 23:46:48 发布

Au-csdn

最新推荐文章于 2024-04-16 23:46:48 发布

阅读量2.9w

点赞数 11

分类专栏：算法文章标签：字节跳动2020校招笔试题

本文链接：https://blog.csdn.net/hzj1998/article/details/99285786

版权

算法专栏收录该内容

7 篇文章 5 订阅

订阅专栏

字节跳动2020届秋招第一批笔试题（`2019.8.11`）

文章目录

字节跳动2020届秋招第一批笔试题（`2019.8.11`）

第一题[编程题25分]：闹钟叫醒去上课

时间限制：C/C++ 1秒，其它语言 2秒
空间限制：C/C++ 32768K，其它语言 65536K
64bit IO Format: %lld

题目描述：

小明总是睡过头，所以他定了很多闹钟，只有在闹钟响的时候他才会醒过来并且决定起不起来。
从他起床算起他需要X分钟到达教室，上课时间为当天的A时B分，请问他最晚可以什么时候起床。

输入描述：

每个输入包含一个测试用例

每个测试用例的第一行包含一个整数，表示闹钟的数量N（N <= 100）

接下来的N行每行包含两个整数，表示这个闹钟响起的时间为Hi（0 <= A < 24）时Mi（0 <= B < 60）分

接下来的一行包含一个整数，表示从他起床算起他需要X（0 <= X <= 100）分钟到达教室

接下来的一行包含两个整数，表示上课时间为A（0 <= A < 24）时B（0 <= B < 60）分

数据保证至少有一个闹钟可以让牛牛及时到达教室

输出描述：

输出两个整数表示牛牛最晚起床时间

示例1：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

输出：

6 0

思路一：创建一个时间对象，包含Hi和Mi，然后将闹钟时间封装成这个时间对象，然后将这些对象排序（快排时间复杂度为 $O（nlog_2n）$ ），然后就简单了，我开始是直接从结尾遍历，找到第一个满足条件的就输出（条件：闹钟时间 + X <= 上课时间），然后终止，然而，并没有通过全部样例，清醒一下，想了一下，有序的序列，查找数据明摆着用二分，就是查找一个序列中最右、最接近标杆的，比如一个序列{1, 2, 3, 3, 3, 4, 10, 10, 11}，当标杆为3时，我们应该要下标为5的那个3，当标杆为5时，我们应该要下标为6的那个4。

AC代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		run();
	}

	public static void run() {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt(); // 闹钟数量
		ArrayList<Time> list = new ArrayList<>();
		for (int i = 0; i < N; ++i) {
			list.add(new Time(scanner.nextInt(), scanner.nextInt())); // 封装成Time对象
		}
		list.sort(new Comparator<Time>() { // 将闹钟们排序
			@Override
			public int compare(Time o1, Time o2) {
				return o1.hi - o2.hi == 0 ? o1.mi - o2.mi : o1.hi - o2.hi;
			}
		});
		int X = scanner.nextInt(), A = scanner.nextInt(), B = scanner.nextInt();
		Time AB = new Time(A, B); // 上课时间
		AB.jian(X);
		int l = 0, r = list.size() - 1;
		while (l <= r) {  // 二分搜索
			int m = (l + r) >> 1;
			if (AB.compareTo(list.get(m)) >= 0) {
				l = m + 1;
			} else {
				r = m - 1;
			}
		}
		if (r < 0) // r可能小于0，因为题目说了保证有解，那就输出第一个闹钟就可以了
			System.out.println(list.get(0));
		else
			System.out.println(list.get(r));
		scanner.close();
	}

	static class Time implements Comparable<Time> { // Time对象，实现Comparable接口，方便比较
		int hi;
		int mi;

		public Time(int hi, int mi) {
			this.hi = hi;
			this.mi = mi;
		}

		public Time jian(int X) { // 时间的减法，6时30分 - 10分 = 6时20分
			int T = hi * 60 + mi;
			int cha = T - X;
			hi = cha / 60;
			mi = cha % 60;
			return this;
		}

		@Override
		public int compareTo(Time o) {
			return hi - o.hi == 0 ? mi - o.mi : hi - o.hi; // 按照小时升序，当小时相同时，按照分钟升序
		}

		@Override
		public String toString() {
			return hi + " " + mi;
		}
	}
}

思路二：由于上面创建了很多闹钟对象，比较费空间，所以我们可以将输入的时间全部转换成分钟，比如6时10分=6*60+10=370分，然后将输入的时间排序（快排时间复杂度为 $O（nlog_2n）$ ），然后二分，思路和上面一样。

AC代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		run();
	}
	public static void run() {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		ArrayList<Integer> list = new ArrayList<>();
		for (int i = 0; i < N; ++i) {
			list.add(scanner.nextInt() * 60 + scanner.nextInt());
		}
		list.sort(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1 - o2;
			}
		});
		int X = scanner.nextInt();
		int A = scanner.nextInt();
		int B = scanner.nextInt();
		int AB = A * 60 + B; // 上课时间，转换成了分钟
		int t = AB - X; // 这就是标杆
		int l = 0, r = list.size() - 1;
		while (l <= r) {
			int m = (l + r) >> 1;
			if (t >= list.get(m)) {
				l = m + 1;
			} else {
				r = m - 1;
			}
		}
		if (r < 0)
			System.out.println(list.get(0) / 60 + " " + list.get(0) % 60);
		else
			System.out.println(list.get(r) / 60 + " " + list.get(r) % 60);
		scanner.close();
	}
}

第二题[编程题25分]：秘密通信

时间限制：C/C++ 1秒，其它语言 2秒
空间限制：C/C++ 32768K，其它语言 65536K
64bit IO Format: %lld

题目描述：

小明和安琪是好朋友。最近，他们的谈话被一家侦探机构监控，所以他们想将他们的谈话内容进行加密处理。
于是，他们发明了一种新的加密方式。每条信息都被编译成二进制数B（明文），其长度为N。
然后该信息被写下K次，每次向右移动0，1，...，K-1位。
例如：B = 1001010，K=4
1001010
 1001010
  1001010
   1001010
然后对每一列进行异或操作，并且把最终所得的结果记录下来，我们将该数称为S（密文）。
例如上述例子的结果为：1110100110。
最后，将编码的信息S和K发送给安琪。
小明已经实现了这种编码的加密过程，但他要求安琪写一个程序去实现这种编码的解密过程，你能帮助安琪实现解密过程吗？

输入描述：

第一行输入两个整数 N 和 K

第二行输入一个二进制字符串S，长度是N + K - 1

输出描述：

输出明文B

示例1：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

7 4
1110100110

输出：

示例2：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

6 2
1110001

输出：

备注：

1 <= N <= 10^6
1 <= K <= 10^6

这个题目没啥算法，就是纯粹找规律，先来看示例一：1110100110，它是这样来的：

 1001010
  1001010
   1001010
^   1001010
-----------
 1110100110

我们把它抽象出来：

 abcdefg
  abcdefg
   abcdefg
^   abcdefg
-----------
 hijklmnopq

这样就很容易看出规律了（opq用不上）：

h = a
i = a ^ b
j = a ^ b ^ c
k = a ^ b ^ c ^ d
l = b ^ c ^ d ^ e
m = c ^ d ^ e ^ f
n = d ^ e ^ f ^ g

我们知道，1 ^ 1 = 0 ^ 0 = 0, 1 ^ 0 = 0 ^ 1 = 1，即相同异或值为0，不同就为1，0与n异或结果为n，而上面的等式我们是已知左边的（hjiklmn），我们可以反过来，根据异或的性质，i = a ^ b可以推出 b = i ^ a（两边同时异或a即可得到）：

h = a           		=>			a = h
i = a ^ b       		=>			b = i ^ a
j = a ^ b ^ c			=>			c = j ^ a ^ b
k = a ^ b ^ c ^ d		=>			d = k ^ a ^ b ^ c
l = b ^ c ^ d ^ e		=>			e = l ^ b ^ c ^ d
m = c ^ d ^ e ^ f		=>			f = m ^ c ^ d ^ e
n = d ^ e ^ f ^ g		=>			g = n ^ d ^ e ^ f

到这里就很简单了，我们把abcdfg分成三部分来看，0，1 ~ k-1，K ~ N-1，，因为这三段执行过程是不一样的，我们设int[] S为输入的01数字（对应hijklmnopq），int[] res为我们要输出的答案（对应abcdefg）：

0：res[0] = S[0]
1 ~ k-1：res[i] = S[i] ^ res[0] ^ ··· ^ res[i - 1]
K ~ N-1：res[i] = S[i] ^ res[i + 1 - K] ^ ··· ^ res[i - 1]

实现代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		run();
	}
	private static void run1() {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		int K = scanner.nextInt();
		scanner.nextLine();
		String S = scanner.nextLine();
		int[] S_int = new int[N + K - 1]; // 将输入的01字符串转化为01整数数组，方便下面进行异或操作
		int[] res = new int[N]; // 输出的结果
		for (int i = 0; i < N + K - 1; ++i) { // 将输入的01字符串转化为01整数数组，方便下面进行异或操作
			S_int[i] = S.charAt(i) - '0';
		}
		res[0] = S_int[0]; // 第一段
		for (int i = 1; i < K; ++i) { // 第二段
			res[i] = S_int[i] ^ yihuo(0, i - 1, res);
		}
		for (int i = K; i < N; i++) { // 第三段
			res[i] = S_int[i] ^ yihuo(i + 1 - K, i - 1, res);
		}
		for (int i = 0, len = res.length; i < len; ++i) {
			System.out.print(res[i]);
		}
		System.out.println();
		scanner.close();
	}

	private static int yihuo(int i, int j, int[] res) { // 返回从i异或到j的值
		int result = res[i];
		for (int t = i + 1; t <= j; t++) {
			result ^= res[t];
		}
		return result;
	}
}

好了，代码写到这里，jj了，只通过了83.33%测试用例，想了一会，发现求当前异或的时候不必再循环求，而是与上一个异或值有关的，发现规律，还可以优化，比如求c = j ^ a ^ b的时候，b是上一步的结果（b = i ^ a），我们带入这个式子，可得c = j ^ a ^ i ^ a，再化简，可得c = i ^ j，求e = l ^ b ^ c ^ d的时候，将d = k ^ a ^ b ^ c带入：

0：res[0] = S[0]
1 ~ k-1：res[i] = S[i] ^ res[0] ^ ··· ^ res[i - 1]
= S[i] ^ res[i - 1] ^ S[i - 1] ^ res[i - 1]
= S[i] ^ S[i - 1]
K ~ N-1：res[i] = S[i] ^ res[i + 1 - K] ^ ··· ^ res[i - 1]
= S[i] ^ res[i - 1] ^ res[i - K] ^ S[i - 1] ^ res[i - 1]
= S[i] ^ res[i - K] ^ S[i - 1]

AC代码：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		run();
	}
	private static void run() {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		int K = scanner.nextInt();
		scanner.nextLine();
		String S = scanner.nextLine();
		int[] S_int = new int[N + K - 1]; // 将输入的01字符串转化为01整数数组，方便下面进行异或操作
		int[] res = new int[N]; // 输出的结果
		for (int i = 0; i < N + K - 1; ++i) { // 将输入的01字符串转化为01整数数组，方便下面进行异或操作
			S_int[i] = S.charAt(i) - '0';
		}
		res[0] = S_int[0]; // 第一段
		for (int i = 1; i < K; ++i) { // 第二段
			res[i] = S_int[i - 1] ^ S_int[i];
		}
		for (int i = K; i < N; i++) { // 第三段
			res[i] = res[i - K] ^ S_int[i - 1] ^ S_int[i];
		}
		for (int i = 0, len = res.length; i < len; ++i) {
			System.out.print(res[i]);
		}
		System.out.println();
		scanner.close();
	}

第三题[编程题25分]：万万没想到之抠门的老板

时间限制：C/C++ 1秒，其它语言 2秒
空间限制：C/C++ 32768K，其它语言 65536K
64bit IO Format: %lld

题目描述：

我叫王大锤，是一家互联网公司的老板，快到年底了，要给员工发奖金。
真头疼，大环境这么差，怎么才能尽可能的少发点、同时还能让大家怨气少一点呢？
公司的座位是排成一排的，每个人都最多打听的到和自己相邻左右两个人的奖金数，我决定这样发：

1. 每个人都至少发100块。
2. 论资排辈：每个人加入公司的年限是公开的，如果一个员工A加入公司的时间比领座的同事B早，那A至少比B多拿100块。这样，他的心理会平衡一些。

我特喵是个天才！将人性理解的如此透彻，做一个小公司的老板真是屈才了。
······
万万没想到，发完奖金，所有员工都离职了，都跳槽去了一家叫字节跳动的公司，他们都说这家公司一不论资排辈，二不吃大锅饭，
奖罚分明，激励到位，老板还特大方，说的我都想去应聘了......

请听题：给定大锤公司员工的座位表，以及每个员工的入职时间，计算大锤最少需要发多少奖金。

输入描述：

第一行只有一个正整数 N （1 <= N <= 1000），表示员工人数

第二行有N个正整数，代表每个员工的入职年限。排列顺序即为员工的座位顺序。

输出描述：

一个数字，代表大锤最少需要发的奖金总数。

示例1：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

4
3 9 2 7

输出：

说明：

每人奖金数为（100，200，100，200）

示例2：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

5
1 2 3 4 5

输出：

说明：

每人奖金数为（100，200，300，400，500）

这个题目的话，直接从左往右遍历，遍历到每个人的时候，再向左向右遍历，向左遍历的时候，如果当前值比右边一个大，则当前值需要取max（后一个值+100，当前值），如果小于右边的，则停止向左试探；向右也是同理。

当然，还有更好的解法，移步leetcode 135：https://leetcode-cn.com/problems/candy/

AC代码：

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		run();
	}

	private static void run() {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		int[] people = new int[N];
		for (int i = 0; i < N; ++i)
			people[i] = scanner.nextInt();
		int[] money = new int[N];
		Arrays.fill(money, 100);
		for (int i = 0; i < N; ++i) {
			for (int j = i - 1; j >= 0; --j) {
				if (people[j] < people[j + 1])
					break;
				money[j] = Math.max(money[j + 1] + 100, money[j]);
			}
			for (int j = i + 1; j < N; ++j) {
				if (people[j] < people[j - 1])
					break;
				money[j] = Math.max(money[j - 1] + 100, money[j]);
			}
		}
		int sum = 0;
		for (int i = 0; i < N; ++i)
			sum += money[i];
		System.out.println(sum);
		scanner.close();
	}
}

第四题[编程题25分]：跑步

时间限制：C/C++ 1秒，其它语言 2秒
空间限制：C/C++ 32768K，其它语言 65536K
64bit IO Format: %lld

题目描述：

小明练习跑步，他家附近的街道是棵树，这棵树上的点按1到n标号，任意两点互相可达，并且有且仅有一条路，每条路的距离都是1，
需要在树上找一条路来跑，小明对3很感兴趣，所以他想知道所有跑道距离和%3=0，1，2的道路总长度一共各有多长。
即树上任意两点间距离%3=k的距离和。

输入描述：

第一行一个n，点数n <=1e5

接下来n - 1行每行u，v一条无向边

输出描述：

一行3个整数，分别代表%3=0，1，2的两点距离的距离和

结果取模1e9 + 7

示例1：（输入输出示例仅供调试，后台判题数据一般不包含示例）

输入：

3
1 2
2 3

输出：

0 2 2

说明：

长度%3=0的距离不存在，=1的有两条1-2，2-3总长度是2，=2的有1条，1-3，总长度是2

备注：

前4个case小数据点数3，10，100，10000

之后数据全部100000个点

Au-csdn

关注

11
点赞
踩
108

收藏

觉得还不错? 一键收藏
10
评论
字节跳动2020届秋招笔试题

字节跳动2020届秋招第一批笔试题（2019.8.11）文章目录字节跳动2020届秋招第一批笔试题（`2019.8.11`）第一题[编程题25分]：闹钟叫醒去上课第二题[编程题25分]：秘密通信第三题[编程题25分]：万万没想到之抠门的老板第四题[编程题25分]：跑步第一题[编程题25分]：闹钟叫醒去上课时间限制：C/C++ 1秒，其它语言 2秒空间限制：C/C++ 32768...
复制链接

扫一扫