字节笔试题（含答案）

总结不易，如果对你有帮助，请点赞关注支持一下
微信搜索程序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);