2019 - 3字节跳动研发部

2023-10-29 05:30
文章标签 字节 跳动 2019 研发部

本文主要是介绍2019 - 3字节跳动研发部，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一

我叫王大锤，是一家出版社的编辑。我负责校对投稿来的英文稿件，这份工作非常烦人，因为每天都要去修正无数的拼写错误。但是，优秀的人总能在平凡的工作中发现真理。我发现一个发现拼写错误的捷径：

  1. 三个同样的字母连在一起，一定是拼写错误，去掉一个的就好啦：比如 helllo -> hello
  2. 两对一样的字母（AABB型）连在一起，一定是拼写错误，去掉第二对的一个字母就好啦：比如 helloo -> hello
  3. 上面的规则优先“从左到右”匹配，即如果是AABBCC，虽然AABB和BBCC都是错误拼写，应该优先考虑修复AABB，结果为AABCC

我特喵是个天才！我在蓝翔学过挖掘机和程序设计，按照这个原理写了一个自动校对器，工作效率从此起飞。用不了多久，我就会出任CEO，当上董事长，迎娶白富美，走上人生巅峰，想想都有点小激动呢！
……
万万没想到，我被开除了，临走时老板对我说： “做人做事要兢兢业业、勤勤恳恳、本本分分，人要是行，干一行行一行。一行行行行行；要是不行，干一行不行一行，一行不行行行不行。” 我现在整个人红红火火恍恍惚惚的……

请听题：请实现大锤的自动校对程序

输入描述:

第一行包括一个数字N，表示本次用例包括多少个待校验的字符串。
后面跟随N行，每行为一个待校验的字符串。

输出描述:

N行，每行包括一个被修复后的字符串。

输入例子1:

2
helloo
wooooooow

输出例子1:

hello
woow

package com.luyi;
import java.util.*;/*** 回溯法*/
public class Main {public ArrayList<Integer> res = new ArrayList<>();public static void main(String[] args) {Scanner in = new Scanner(System.in);int n = in.nextInt();while (n > 0) {String str = in.next();char[] chars = str.toCharArray();StringBuilder sb = new StringBuilder();boolean flag = false;String temp = "";for (int i = 0; i < chars.length; i++) {if (flag) {while (i < chars.length && temp.equals(chars[i] + "")) {i++;}if (i < chars.length) {sb.append(chars[i] + "");temp = chars[i] + "";}} else {sb.append(chars[i] + "");temp = chars[i] + "";}if (i + 1 < chars.length && chars[i + 1] == chars[i]) {sb.append(chars[i + 1] + "");temp = chars[i + 1] + "";flag = true;i++;while (i + 1 < chars.length && (chars[i + 1] + "").equals(temp)) {i++;}if (i + 1 < chars.length) {sb.append(chars[i + 1] + "");temp = chars[i + 1] + "";i++;}} else {flag = false;}}System.out.println(sb.toString());n--;}}}

二

我叫王大锤，是一名特工。我刚刚接到任务：在字节跳动大街进行埋伏，抓捕恐怖分子孔连顺。和我一起行动的还有另外两名特工，我提议

  1. 我们在字节跳动大街的N个建筑中选定3个埋伏地点。

  2. 为了相互照应，我们决定相距最远的两名特工间的距离不超过D。

我特喵是个天才! 经过精密的计算，我们从X种可行的埋伏方案中选择了一种。这个方案万无一失，颤抖吧，孔连顺！

……

万万没想到，计划还是失败了，孔连顺化妆成小龙女，混在cosplay的队伍中逃出了字节跳动大街。只怪他的伪装太成功了，就是杨过本人来了也发现不了的！

请听题：给定N（可选作为埋伏点的建筑物数）、D（相距最远的两名特工间的距离的最大值）以及可选建筑的坐标，计算在这次行动中，大锤的小队有多少种埋伏选择。

注意：

  1. 两个特工不能埋伏在同一地点

  2. 三个特工是等价的：即同样的位置组合(A, B, C) 只算一种埋伏方法，不能因“特工之间互换位置”而重复使用

输出描述:

一个数字，表示不同埋伏方案的数量。结果可能溢出，请对 99997867 取模

示例1

输入

4 3
1 2 3 4
输出
4
说明
可选方案 (1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)
示例2

输入

5 19
1 10 20 30 50

输出

1

说明

可选方案 (1, 10, 20)

java会超时 py不回 真的操蛋 java要是不超时就将右指针和左指针地位调换 确定右指针的占位置 调整左指针
下面是正常人思维的超时算法 不超时的太反人类了了 就不写进来!!

		public static void main(String[] args) {Scanner in = new Scanner(System.in);int n = in.nextInt();int d = in.nextInt();if (n < 3) {System.out.println(0);}  else {int [] arr = new int[n];int temp = 0;while (temp < n) {arr[temp++] = in.nextInt();}long res = 0;int right;for (int i = 0; i < n - 2; i++) {right = i + 2;while (right < n && arr[right] - arr[i] <= d) {right++;}right --;res += (long)(right - i - 1) * (right - i) / 2;}System.out.println(Math.floorMod(res,99997867));}}

三 雀魂

小包最近迷上了一款叫做雀魂的麻将游戏，但是这个游戏规则太复杂，小包玩了几个月了还是输多赢少。
于是生气的小包根据游戏简化了一下规则发明了一种新的麻将，只留下一种花色，并且去除了一些特殊和牌方式（例如七对子等），具体的规则如下：

总共有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个或以上的数字。代表他再取到哪些牌可以和牌。若满足条件的有多种牌，请按从小到大的顺序输出。若没有满足条件的牌，请输出一个数字

package com.luyi;
import java.util.*;/*** 回溯法*/
public class Main {public ArrayList<Integer> res = new ArrayList<>();public static void main(String[] args) {Main main = new Main();Scanner in = new Scanner(System.in);int[] arr = new int[14];for(int i = 0; i < 13; i++) {arr[i] = in.nextInt();}int[] numArr = main.getNum(arr);int num;for (int i = 1; i <= 9; i++) { // 判断是否可以加入该牌if (numArr[i] < 4) {numArr[i]++;for (int j = 1; j <= 9; j++) {if (numArr[j] >= 2 ) { // 判断是否可以做头numArr[j] -= 2;num = 12;main.check( numArr, num, i);numArr = main.getNum(arr);numArr[i]++;}}numArr = main.getNum(arr);}}if (main.res.isEmpty()){System.out.println(0);} else {for (int i = 0; i < main.res.size(); i++) {if (i == main.res.size() - 1) {System.out.print(main.res.get(i));} else {System.out.print(main.res.get(i) + " ");}}}}public void check(int[] numArr, int num, int add) {if (num == 0) {if(!res.contains(add)) {res.add(add);}} else {for (int i = 1; i < numArr.length; i++) { // 判断是不是刻子if (numArr[i] >= 3) {numArr[i] -= 3;num -= 3;check(numArr, num, add); // 递归// 回溯numArr[i] += 3;num += 3;}// 判断是否顺子if (i == 1) {if (numArr[1] > 0 && numArr[3] > 0 && numArr[2] > 0) {numArr[1]--;numArr[2]--;numArr[3]--;num -= 3;check(numArr, num, add);}} else if(i == 8) {if (numArr[7] > 0 && numArr[8] > 0 && numArr[9] > 0) {numArr[7]--;numArr[8]--;numArr[9]--;num -= 3;check(numArr, num, add);}} else if (i <= 7){if (numArr[i - 1] > 0 && numArr[i] > 0 && numArr[i + 1] > 0) {numArr[i - 1]--;numArr[i]--;numArr[i + 1]--;num -= 3;check(numArr, num, add);}}}}}public int[] getNum(int[] arr ) {int[] temp = new int[10];for (int i = 1; i <= 9; i++) {for (int j = 0; j < arr.length; j++) {if (arr[j] == i) {temp[i]++;}}}return temp;}
}

四

小明是一名算法工程师，同时也是一名铲屎官。某天，他突发奇想，想从猫咪的视频里挖掘一些猫咪的运动信息。为了提取运动信息，他需要从视频的每一帧提取“猫咪特征”。一个猫咪特征是一个两维的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:

特征<1,1>在连续的帧中连续出现3次，相比其他特征连续出现的次数大，所以输出3

package com.luyi;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;/*** 复杂数据结构 + 动态规划**/
public class Main {public static void main(String[] args) {List<Data> dataList = new ArrayList<>();List<List<Data>> zList = new ArrayList<>();Scanner in = new Scanner(System.in);int n = in.nextInt();while ((n--) > 0) {// 取数 放在一个数组里 List<List<Data>> zListint z = in.nextInt();for (int i = 0; i < z; i++) {int zn = in.nextInt();for (int j = 0; j < zn; j++) {dataList.add(new Data(in.nextInt(), in.nextInt()));}zList.add(dataList);dataList = new ArrayList<>();}Map<String, Integer> res = new HashMap<>();List<Map<String, Integer>> resList = new ArrayList<>();List<String> temp = new ArrayList<>();int index = 0;for (List<Data> item : zList) {if (index > 0) {res = new HashMap<>(resList.get(index - 1));for (Data val : item) {if (!res.containsKey(val.toString())) {res.put(val.toString(), 1);temp.add(val.toString());} else {temp.add(val.toString());if (zList.get(index - 1).stream().anyMatch(ss -> ss.a == val.a && ss.b == val.b)){res.put(val.toString() ,res.get(val.toString()) + 1);} else {res.put(val.toString(), 1);}}}Map<String, Integer> finalRes = res;for (Map.Entry data : res.entrySet()) {if (!temp.contains(data.getKey())) {finalRes.put((String) data.getKey(), 0);}}temp = new ArrayList<>();res = finalRes;} else {for (Data val : item) {res.put(val.toString(), 1);}}resList.add(res);index++;}final int[] max = {0};AtomicReference<String> v  = new AtomicReference<>("");resList.forEach(ss -> {for(Map.Entry data : ss.entrySet()) {if ((Integer)data.getValue() > max[0]) {max[0] = (Integer)data.getValue();v.set((String) data.getKey());}}});System.out.println(max[0]);}}
}class Data{int a;int b;public Data(int a, int b) {this.a = a;this.b = b;}@Overridepublic String toString() {return "Data{" +"a=" + a +", b=" + b +'}';}
}

五

小明目前在做一份毕业旅行的规划。打算从北京出发，分别去若干个城市，然后再回到北京，每个城市之间均乘坐高铁，且每个城市只去一次。由于经费有限，希望能够通过合理的路线安排尽可能的省一些路上的花销。给定一组城市和每对城市之间的火车票的价钱，找到每个城市只访问一次并返回起点的最小车费花销。

输入描述:

城市个数n（1<n≤20，包括北京）
城市间的车票价钱 n行n列的矩阵 m[n][n]

输出描述:

最小车费花销 s

输入例子1:

4
0 2 6 5
2 0 4 4
6 4 0 2
5 4 2 0

输出例子1:

13

例子说明

共 4 个城市，城市 1 和城市 1 的车费为0，城市 1 和城市 2 之间的车费为 2，城市 1 和城市 3 之间的车费为 6，城市 1 和城市 4 之间的车费为 5，依次类推。假设任意两个城市之间均有单程票可购买，且票价在1000元以内，无需考虑极端情况。

public int travelPlanII(int[][] arr) {// Write your code here.int n = arr.length;int flag = 1 << n;  //  00000001向左移动n位 也就等于 2^n int[][] dp = new int[flag][n];for (int i = 0; i < flag; i++) {for(int j = 0; j < n; j++) {dp[i][j] = Integer.MAX_VALUE;    }   }dp[1][0] = 0; // 设置 A到A的花费为0for (int i = 1; i < flag; i++) {for(int j = 0; j < n; j++) {if (dp[i][j] != Integer.MAX_VALUE) { // 判断是否 for (int k = 0; k < n; k++) {if ((i & 1 << k) == 0) {   // &运算  两个同时为1才为1 其他都是0// | 运算  一个为1 就等于1  其他都是0dp[i | (1 << k)][k] = Math.min(dp[i | (1 << k)][k], dp[i][j] + arr[j][k]);}}} }   }int res = Integer.MAX_VALUE;for (int i = 0; i < n; i++) {res = Math.min(res, dp[flag - 1][i] + arr[i][0]);}return res;}

六

Z国的货币系统包含面值1元、4元、16元、64元共计4种硬币，以及面值1024元的纸币。现在小Y使用1024元的纸币购买了一件价值为在这里插入图片描述
的商品，请问最少他会收到多少硬币？

输入描述:

一行，包含一个数N。

输出描述:

一行，包含一个数，表示最少收到的硬币数。

输入例子1:

200

输出例子1:

17

例子说明1:

花200，需要找零824块，找12个64元硬币，3个16元硬币，2个4元硬币即可。

package com.luyi;
import java.util.*;/*** 动态规划  算最后一步  f[x] =  Math.min(f[x - 1] + 1, f[x - 4] + 1, f[x - 16] + 1, f[x - 64] + 1)**/
public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);int[] coins = new int[4];coins[0] = 1;coins[1] = 4;coins[2] = 16;coins[3] = 64;int n = in.nextInt();n = 1024 - n;int[] dp = new int[n + 1];dp[0] = 0;for (int i = 1; i < n + 1; i++) {dp[i] = 65535;for (int j = 0; j < coins.length; j++) {if (i - coins[j] >= 0 && dp[i -coins[j]] != 65535)dp[i]  = Math.min(dp[i -coins[j]] + 1, dp[i]);}}System.out.println(dp[n]);}
}

七

机器人正在玩一个古老的基于DOS的游戏。游戏中有N+1座建筑——从0到N编号，从左到右排列。编号为0的建筑高度为0个单位，编号为i的建筑的高度为H(i)个单位。

起初， 机器人在编号为0的建筑处。每一步，它跳到下一个（右边）建筑。假设机器人在第k个建筑，且它现在的能量值是E, 下一步它将跳到第个k+1建筑。它将会得到或者失去正比于与H(k+1)与E之差的能量。如果 H(k+1) > E 那么机器人就失去 H(k+1) - E 的能量值，否则它将得到 E - H(k+1) 的能量值。

游戏目标是到达第个N建筑，在这个过程中，能量值不能为负数个单位。现在的问题是机器人以多少能量值开始游戏，才可以保证成功完成游戏？

输入描述:

第一行输入，表示一共有 N 组数据.
第二个是 N 个空格分隔的整数，H1, H2, H3, …, Hn 代表建筑物的高度

输出描述:

输出一个单独的数表示完成游戏所需的最少单位的初始能量

输入例子1:

5
3 4 3 2 4

输出例子1:

4

输入例子2:

3
4 4 4

输出例子2:

4

输入例子3:

3
1 6 4

输出例子3:

3

package com.luyi;
import java.util.*;/***  当 E < h(i) E = E - (H - E) = 2 * E - H *  当 E > h(i) E = E + (E + H) = 2 * E - H*  *  E= (Ei + h(i)) / 2;* */
public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);int n = in.nextInt();int[] arr = new int[n];for (int i = 0; i < n; i++) {arr[i] = in.nextInt();}int res = 0;for (int i = n - 1; i >= 0; i--) {res = ((res + arr[i])% 2 == 0?res + arr[i] : res + arr[i] + 1) / 2;}System.out.println(res);}
}

这篇关于2019 - 3字节跳动研发部的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/298545。

相关文章

Go语言使用Buffer实现高性能处理字节和字符

Go语言使用Buffer实现高性能处理字节和字符

《Go语言使用Buffer实现高性能处理字节和字符》在Go中,bytes.Buffer是一个非常高效的类型,用于处理字节数据的读写操作,本文将详细介绍一下如何使用Buffer实现高性能处理字节和... 目录1. bytes.Buffer 的基本用法1.1. 创建和初始化 Buffer1.2. 使用 Writ
阅读更多...
.NET利用C#字节流动态操作Excel文件

.NET利用C#字节流动态操作Excel文件

《.NET利用C#字节流动态操作Excel文件》在.NET开发中,通过字节流动态操作Excel文件提供了一种高效且灵活的方式处理数据,本文将演示如何在.NET平台使用C#通过字节流创建,读取,编辑及保... 目录用C#创建并保存Excel工作簿为字节流用C#通过字节流直接读取Excel文件数据用C#通过字节
阅读更多...
字节面试 | 如何测试RocketMQ、RocketMQ？

字节面试 | 如何测试RocketMQ、RocketMQ？

字节面试：RocketMQ是怎么测试的呢？ 答： 首先保证消息的消费正确、设计逆向用例，在验证消息内容为空等情况时的消费正确性； 推送大批量MQ，通过Admin控制台查看MQ消费的情况，是否出现消费假死、TPS是否正常等等问题。（上述都是临场发挥，但是RocketMQ真正的测试点，还真的需要探讨） 01 先了解RocketMQ 作为测试也是要简单了解RocketMQ。简单来说，就是一个分
阅读更多...
BUUCTF靶场[web][极客大挑战 2019]Http、[HCTF 2018]admin

BUUCTF靶场[web][极客大挑战 2019]Http、[HCTF 2018]admin

目录   [web][极客大挑战 2019]Http 考点：Referer协议、UA协议、X-Forwarded-For协议 [web][HCTF 2018]admin 考点：弱密码字典爆破 四种方法：   [web][极客大挑战 2019]Http 考点：Referer协议、UA协议、X-Forwarded-For协议 访问环境 老规矩，我们先查看源代码
阅读更多...
JVM - 字节码文件详解

JVM - 字节码文件详解

文章目录 目录 文章目录 1. 无关性基石 2. Class类文件结构 magic- 魔数 主副版本号 常量池 访问标志 类索引,父类索引与接口索引集合 字段 方法 属性 3. 类加载机制 类的生命周期 类加载过程 加载 连接 验证 准备 解析 初始化 4. 类加载器 类与类加载器 类加载器的分类 启动类加载器  扩展类加载器 应用程序类加
阅读更多...
SylixOS write 0 字节问题

SylixOS write 0 字节问题

1 问题描述 在移植中间件过程中，在SylixOS调用write函数写入0字节的数据到文件中时，会导致对应的中间件测试用例失败，失败的原因是文件系统中的write函数在Linux系统和SylixOS有区别，两种实现的差别如下。 2 write函数的实现机制 2.1 SylixOS实现机制 在SylixOS下通过write 函数写数据到普通文件中时，第一步会判断写入的数据是否为0，如果是0直
阅读更多...
2019学习计划

2019学习计划

工作三年了，第一年感觉是荒废的，第二年开始学习python，第三年开始自动化 感觉自己会的东西比较少，而且不够深入，流于表面 现制定一下今年大概的学习计划 需持续巩固加强：python、ui自动化、接口自动化、sql等 代码量需提升，敲的不够（重点） 学习： 1.移动端测试，appium等 2.前端知识系统整理学习  3.性能测试 4.docker入门，环境搭建 5.shell
阅读更多...
CPU大小端字节序的检测

CPU大小端字节序的检测

机器的字节序有两种，即大端字节序和小端字节序。 大端字节序：在内存中，低地址存放数据的 高位，高地址存放数据的 低位 小端字节序：在内存中，低地址存放数据的 低位，高地址存放数据的 高位 如例：定义数据  a = 0x01020304 小端方式：01 02 03 04 大端方式：04 03 02 01 那么如何判断呢，方式如下--> 一、 指
阅读更多...
68-java字符流和字节流

68-java字符流和字节流

Java中的字符流和字节流是用于处理输入/输出的两大类。字符流主要用于处理字符数据，而字节流可以处理任何类型的数据。 字符流： Reader：用于读取字符流的抽象类。 Writer：用于写入字符流的抽象类。 字节流： InputStream：用于读取字节流的抽象类。 OutputStream：用于写入字节流的抽象类。 下面是使用字符流和字节流的简单示例： 字符流示例（文件复
阅读更多...
1字节的UTF-8序列的字节1无效

1字节的UTF-8序列的字节1无效

使用DOMReader解析XML文档时候报错”1字节的UTF-8序列的字节1无效”，我这里的解决方法。 1.手动将< ? xml version=”1.0” encoding=”UTF-8”?>中的UTF-8更改成UTF8，这样就可以了。 2.使用文本编译器把xml文档改成以UTF8无BOM编码格式就可以了。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2